【JavaScript_2】js(ES5)中的六种继承方式

先说一下ES5和ES6中继承的区别吧，ES5中主要就是利用原型、原型链、构造函数来搞，ES6中是利用class类继承。

1. 原型链的方式

new一个父类的实例，并将其作为子类的prototype。

// 为父类添加实例属性
function SuperType() {
    this.super = "super";
    this.arr = [1, 2, 3];
}
// 为父类添加原型方法
SuperType.prototype.getSuperValue = function () {
    return this.super;
};

// 为子类添加实例属性
function SubType() {
    this.sub = "sub";
}
// 让子类，以原型链的方式，继承父类
SubType.prototype = new SuperType();

// 实例化一个子类对象，它可以访问父类的实例属性和原型方法
let subInstance = new SubType();
console.log(subInstance.sub);             // 输出：sub
console.log(subInstance.super);           // 输出：super
console.log(subInstance.getSuperValue()); // 输出：super

// 用子类new出来的对象，既是子类的实例，也是父类的实例
console.log(subInstance instanceof SubType);    // 输出：true
console.log(subInstance instanceof SuperType);  // 输出：true

// 再实例化一个子类对象，并修改其继承来的父类的引用型实例属性
let subInstance1 = new SubType();

subInstance1.arr.push(4);
console.log(subInstance1.arr);  // 输出：[1, 2, 3, 4]
console.log(subInstance.arr);   // 输出：[1, 2, 3, 4]

subInstance1.arr = [2, 2, 2];
console.log(subInstance1.arr);  // 输出：[2, 2, 2]
console.log(subInstance.arr);   // 输出：[1, 2, 3, 4]

// 为父类新增一个原型方法
SuperType.prototype.newMethod = function () {
    console.log("我是父类新增的原型方法");
};
subInstance.newMethod();  // 输出：我是父类新增的原型方法

【特点】
1.父类型后来新增的原型属性和原型方法，子类行也能访问到；
2.用子类new出来的对象，既是子类的实例，也是父类的实例（因为原型链嘛）。

【存在的问题】
1.父类中如果包含引用型的数据，它们会被所有子类实例共享，一旦一个子类实例对其进行了修改，就会造成混乱。
2.在实例化一个子类对象的时候，不能向父类的构造函数传参；
3.因为子类只能选择一个父类设置为自己的原型，所以无法实现多继承。

2. 盗用构造函数的方式

在子类的构造函数中调用父类的构造函数，相当于是子类盗用了父类的构造函数。所以当用子类的构造函数去new一个对象时，使用的还是父类的构造函数，会将父类中的实例属性和实例方法复制一份给这个新对象，而父类原型上的属性和方法不会添加到新对象上。

function SuperType() {
    this.color = ['red', 'green', 'yello'];
}

function SubType() {
    // 在子类的构造函数中，盗用父类的构造函数
    SuperType.call(this);
}

let subInstance = new SubType();
let subInstance1 = new SubType();

subInstance.color.push('while');
// 子类实例之间，对于继承来的引用型的数据，修改起来互不干扰
console.log(subInstance.color);   // 输出：[ 'red', 'green', 'yello', 'while' ]
console.log(subInstance1.color);  // 输出：[ 'red', 'green', 'yello' ]

【特点】
1.父类中的实例属性和方法，都是复制了一份然后添加到子类实例中的，所以即使存在引用型的属性，那子类实例间进行修改时也不会互相干扰；
2.初始化子类实例时，可以向构造函数传参了；
3.在子类构造函数内部，可以.call或.apply多个父类的构造函数，实现多继承。

【存在的问题】
1.只能继承父类的实例属性和实例方法，父类原型链上的属性和方法无法继承；
2.由于子类继承的父类的实例属性，是给每个子类都复制了一份，导致方法没能复用，多占用了内存。

3. 组合继承（原型链+盗用构造函数）

通过盗用父类的构造函数，来继承父类的实例属性；通过将父类的实例作为子类的原型，来继承父类原型上的属性和方法。

// 下次有空了再补充代码填坑

【特点】
将原型链继承与盗用构造函数继承相结合，既能实现定义在原型上的原型方法和属性的复用，也可以让每个子类实例拥有各自独立的实例属性。

【存在的问题】
1.封装性不好。因为分别使用构造函数、原型链来实现的继承；
2.父类的构造函数被调用了两次。一次是在子类构造函数内部，一次是在SubType.prototype = new SuperType();

4. 原型式继承

原型式继承其实有点像原型链继承。
但不同的是，原型链继承中需要显式地去定义一个子类，然后让这个子类的prototype指向父类的一个实例；而原型式继承不需要显式地定义一个子类，直接用Object.create()，传入一个父类的实例，这样就能创建出一个prototype指向该父类的子类实例对象，它能共享父类原型链上的所有属性和方法。

// Object.create()的原理
function object(superObj){
    function Fn(){}
    Fn.prototype = superObj;
    var subObj = new Fn();
    return subObj;
}

【特点】
1.不需要显式地定义一个子类；
2.不会调用父类的构造函数。

【适合的使用场景】
不想去显式地创建一个子类，但想在子类的实例之间共享一些数据。

【存在的问题】
存在与原型链中一样的问题：
1.引用型数据在子类实例间共享；
2.无法实现多继承。

5. 寄生式继承

寄生式继承，可以看作在原型式继承的基础上，又多做了一步——增强该子类对象。
新封装一个函数，在这个函数内部用Object.create()完成原型式继承之后，再给这个新对象添加一些属性或方法，增强该对象，然后返回。

function createAnother(originalObj){
    // 通过原型式继承，创建一个新对象
    var obj = Object.create(originalObj);

    // 增强该对象
    obj.sayHi = function(){
        alert("Hi");
    };

    // 返回这个对象
    return obj;
}

6. 寄生式组合继承

在组合继承中，是使用了“构造函数+原型链”的方式，但构造函数、原型链各调用了父类的构造函数一次，总共调用了两次，在一些完美主义者眼中这种继承方法不完美。。。所以想要研究出一种只需要调用一次父类构造函数的继承方法。。寄生式组合继承就实现了。
寄生式组合继承 = 盗用构造函数 + 寄生式继承
盗用父类构造函数，继承实例属性和方法；
使用寄生式继承，继承父类原型上的属性和方法。

// 封装一个用于寄生式继承的函数
function inherit(superType, subType) {
	// 1.利用父类的实例，创建出该实例的一个副本protoType
	var protoType = Object.create(superType);  
	// 2.增强该副本
	protoType.sayHi = function() {
		alert("Hi, I'm SubType!");
	};
	// 3.将子类的prototype指到父类实例的副本上
	subType.prototype = protoType;
}

// 给父类添加实例属性和原型方法
function Supertype(name){
    this.name = name;
    this.colors = ["red", "green", "blue"];
}
Supertype.prototype.sayName = function(){
    console.log(this.name);
};
​
function Subtype(name,age){
    // 通过盗用父类的构造函数，完成实例属性的继承
    Supertype.call(this,name);
    this.age = age;
}
​
// 用封装好的寄生式继承方法，继承父类原型上的属性和方法
inheritPrototype(Subtype, Supertype);

『寄生组合式继承被认为是引用类型最理想的继承范式』还需要好好理解啊！！！

参考资料：
https://www.cnblogs.com/annika/p/9073572.html