function SuperClass() {
    this.x = 'I am super'
}
SuperClass.prototype.say = function() {
    console.log(this.x)
}

一：原型链继承，一般不用

缺点1：包含引用类型值时会改变
缺点2：无法在不影响所有原型对象时，向超类型的构造函数传递参数

function SubClass1() {
    this.y = 4
}
SubClass1.prototype = new SuperClass()
new SubClass1().say() // I am super

二：借用构造函数，一般不用

function SubClass2() {
    SuperClass.call(this)
}
new SubClass2().say() // not a function,说明无法复用原型链上的方法

SubClass2.prototype.subSay = function() {
    console.log(this.x)
}
new SubClass2().subSay() // I am super

三：组合继承，唯一缺点：调用了两次超类型构造函数

function SubClass3() {
    SuperClass.call(this)
    this.y = '4'
}
SubClass3.prototype = new SuperClass()
new SubClass1().say() // I am super

四：原型式继承,缺点是和原型链一样的

function create(obj) {
    function F() {}
    F.prototype = obj
    return new F();
}

const subClass4 = create(new SuperClass())

五：寄生式继承，即以工厂模式再次封装以增强对象

function parasitic(obj) {
    var clone = create(obj)
    // 增强对象
    clone.sayHi = function() {
        console.log(this.x + 'Hi')
    }
    return clone
}

六：寄生组合式继承，普遍认为最好

function inheritPrototype(SubClass6, SuperClass) {
    var prototype = create(obj)
    prototype.constructor = SuperClass
    SubClass6.prototype = prototype
}

七：Es6继承

class SuperClass {
    constructor() {
        this.x = 'I am super'
    }
    say() {
        console.log(this.x)
    }
}
class SubClass7 extends SuperClass {
    constructor() {
        super() // 必须调用超类构造函数，否则报错
        this.x = 'I am Sub'
    }
}