首先，定义一个父类

function Father (name) {
  this.name = name
  this.getName = function () {
    return this.name
  }
  this.setName = function (name) {
    this.name = name
  }
}

原型链继承

function Son (name) {
  this.name = name
}
Son.prototype = new Father()

缺点：
没有使用Father的构造函数，也即没有复用Father的this.name=name
所有Son的实例共享一个Father实例，它的改变会影响到所有实例

构造函数继承

function Son () {
  Father.apply(this, arguments)
}

缺点：
没有继承Father的原型
Father构造函数每次实例化都被调用

组合继承

function Son () {
  Father.apply(this, arguments)
}
Son.prototype = new Father()

缺点：
仍然没有解决Father构造函数多次调用问题

原型式继承

/**
  @param {*} father 
*/
function inherit(father) {
  function Fn () {}
  Fn.prototype = father
  return new Fn()
}
var son = inherit(new Father())

原型式继承也就是生成一个原型对象是给定对象的对象
对比：
解决了原型继承共享的问题
缺点：
继承的是Father实例不是原型
需要自行修改Son实例特定的属性和方法

寄生式继承

function inherit(father) {
  function Fn () {}
  Fn.prototype = father
  return new Fn()
}
// 寄生函数
function Son (father, name) {
  var son = inherit(father)
  son.name = name
  return son
}
var son = Son(new Father())

寄生式继承就是先得到一个原型上“复制”Father的对象，然后在这个对象中添加新的需要的属性，就像寄生在这个对象中一样。
对比：
解决了自定属性问题

寄生组合式继承

function inherit(father) {
  function Fn () {}
  Fn.prototype = father
  return new Fn()
}
function Son () {
  Father.apply(this, arguments)
}
var tmp = inherit(Father.prototype)
Son.prototype = tmp
tmp.constructor = Son

寄生组合式继承就是原型式继承时继承的是Father的原型而不是实例，这实现了原型继承
同时，寄生函数使用调用Father构造函数的方式，复用构造函数

Object.create

var son = Object.create(new Father())

extends

class Son extends Father {}