SOURCE

/**【原型链继承】
 * 子类原型指向父类实例
 * 
 * [好处]子类可以访问到父类新增原型方法和属性
 * [坏处]无法实现多继承;创建实例不能传递参数
 */
function Parent1(){ }
function Child1(){ }
Child1.prototype = new Parent1();
const child1 = new Child1()


/**【构造函数】
 * 
 * [好处]可以实现多继承；创建实例可以传递参数
 * [坏处]实例并不是父类的实例，只是子类的实例;
 *      不能继承父类原型上的方法
 */
function Parent2(){ }
function Child2(...args){
    Parent2.call(this,...args) // Parent2.apply(this,args)
}
const child2 = new Child2(1)

/**【组合继承】
 * 
 * [好处]属性和原型链上的方法都可以继承;
 *      创建实例可以传递参数
 */
function Parent3(){ }
function Child3(...args){
    Parent3.call(this,...args)
}
Child3.prototype = Object.create(Parent3.prototype)
Child3.prototype.constructor = Child3
const child3 = new Child3(1)

/**【对象继承】
 * 
 * [好处]可以继承属性和方法
 * [坏处]创建实例无法传递参数;
 *      传入对象的属性有引用类型，所有类型都会共享相应的值
 */
//通过Object.create
const Parent4_1 = {prototype:'value',method(){ } }
const Child4_1 = Object.create(Parent4_1)
//自定义create方法
const Parent4_2 = {prototype:'value',method(){ } }
function create4(obj){
    function F(){ }
    F.prototype = obj;
    return new F()
}
const child4 = create4(Parent4_2)

/**【寄生组合继承】
 * 
 */
function Parent5(){ }
function Child5(...args){
    Parent5.call(this,...args)
}
function create5(obj){
    function F(){ }
    F.prototype = obj
    return F()
}
function extend5(Child,Parent){
    const clone = create5(Parent.prototype)
    clone.constructor = Child;
    Child.prototype = clone;
}
extend5(Child5,Parent5)
const child5 = new Child5(1)

/**【es6继承】
 * 
 */
class Parent6 {
    constructor(property){//property译为财产
        this.property = property
    }
    method(){ }
}
class Child6 extends Parent6{
    constructor(property){
        super(property)
    }
}