js 实现继承的方式有：
- 原型链继承；
- 构造函数继承；
- 组合继承（原型链继承 + 构造函数继承）（最常用）；
（原型式继承；
寄生式继承；） - 寄生组合继承 （最佳方式）
继承方式之间的联系
原型链继承
function Super () {
this.name = 'hhh';
this.arr = ['nb'];
}
function Sub () {}
Sub.prototype = new Super();
let sub1 = new Sub();
let sub2 = new Sub();
sub1.name = 'yyy';
sub1.arr.push('hehe');
console.log(sub1.name, sub1.arr); // 'yyy', ['nb', 'hehe']
console.log(sub2.name, sub2.arr); // 'hhh', ['nb', 'hehe']
-
实现的本质是重写原型对象，代之以一个新类型的实例。
Sub.prototype=new Super()；从而使子类得以继承父类的属性和方法。
注意这里sub1.constructor === Super为 true。(Sub.prototype.__proto__ === Super.prototype实例属性的查找自下往上进行查找的原则)
- 优缺点：
优点：简单，易于实现。
缺点：
- 包含引用类型的原型属性会被所有实例共享；（这也是为什么要在构造函数中定义属性，而不是在原型对象中定义属性的原因）。从例子中可以看出实例 sub1 修改 arr 后，也会改变 实例 sub2.arr 的值。
- 创建子类实例时，无法向父类构造函数传参。实际上，应该说无法在不影响所有实例对象的情况下，给父类的构造函数传递参数。
构造函数继承
function Super(name) {
this.name = name;
this.arr = ['nb'];
this.fun = function() {
// ...
}
}
function Sub(name) {
this.hobby = 'hhh';
Super.call(this, name);
// Super.call(this); 可传参 可不传
}
let sub1 = new Sub('xql');
let sub2 = new Sub('nnn');
sub1.name = 'xxx';
sub1.arr.push('hehe')
console.log(sub1.name, sub1.arr); // xxx, ['nb', 'hehe']
console.log(sub2.name, sub2.arr); // nnn, ['nb']
实现的本质：借用父类的构造函数来增强子类实例。等于是把父类的实例属性复制了一份给子类实例装上了（完全没有用到原型）
优缺点：
优点：
- 解决了子类实例共享父类引用属性的问题；
- 创建子类实例时，可以向父类构造函数传参；
- 可以实现多继承（call多个父类对象）；
缺点：
- 方法都在构造函数中定义，函数复用也就无从谈起了。每个子类都有父类实例属性副本。每个子类实例都持有父类的所有函数方法，太多了就会影响性能，内存爆炸。。
- 只能继承父类的实例属性和方法，不能继承父类原型属性和方法。
- 实例并不是父类的实例，只是子类的实例。
组合继承（原型链继承 + 构造函数继承）！！！
function Super(name) {
// 只在此处声明基本属性和引用属性
this.name = name;
this. arr = ['nb'];
}
// 在原型处声明函数
Super.prototype.fun1 = function() {}
Super.prototype.fun2 = function() {}
// ...
function Sub(name) {
this.hobby = 'hhh';
Super.call(this, name); // 核心 第二次调用父类构造函数
}
Sub.prototype = new Super(); // 核心 第一次调用父类构造函数
Sub.prototype.constructor = Sub; // 需要修复构造函数的指向
Sub.prototype.fun11 = function() {}
let sub1 = new Sub('xql');
console.log(sub1);
console.log(sub1);
- 实现的本质：把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点。（使用原型链实现对原型属性和方法的继承（一般不在原型上写引用属性），而通过借用构造函数来实现对实例属性的继承）。即在原型上定义方法实现了函数复用，又能保证每个实例都有它自己的属性。
通过Super.call(this);继承父类的基本属性和引用属性并保留能传参的优点；
通过Sub.prototype = new Super();继承父类函数，实现函数复用。
- 注：组合继承需要修复构造函数的指向。因为重写了原型对象
Sub.prototype，这里Sub.prototype.constructor便指向了构造函数Super，需要修复！！！
Sub.prototype = new Super();
Sub.prototype.constructor = Sub;
- 优缺点：
优点：
- 函数可复用；
- 可以继承实例属性/方法，也可以继承原型属性/方法；
- 既是子类的实例，也是父类的实例；
- 不存在引用属性共享问题；
- 可传参
ps: 修复了上述两种方式的缺点。
缺点：子类原型上有一份多余的父类实例属性；因为父类构造函数被调用了两次，生成了两份；而子类实例上的那一份屏蔽了子类原型上的。又是内存浪费。
第一次Super.call(this);语句从父类拷贝了一份父类实例属性给子类作为子类的实例属性;
第二次Sub.prototype = new Super();创建父类实例作为子类原型，此时这个父类实例就又有了一份实例属性，但这份会被第一次拷贝来的实例属性屏蔽掉，所以多余。
即子类原型上的这份父类实例永远用不到，被子类实例上的父类实例覆盖掉了。
原型式继承（对象的浅复制）
function object(obj) {
function F() {} // 临时的构造函数
F.prototype = obj;
return new F();
}
- 实现的本质：借助原型，基于已有的对象创建一个新对象（相当于对这个对象进行一次浅复制），不必创建自定义类型了（构造函数）,得到一个‘纯洁’的新对象（没有任何实例属性，可看下面的例子）。（类似简化版的原型链继承）
ES5提供了Object.create()函数，内部就是原型式继承，IE9+支持
let person = {
name: 'xql',
friends: ['bb', 'jj', 'hh', 'yy', 'nn']
}
let per1 = object(person);
// let per1 = Object.create(person);
let per2 = object(person);
// let per2 = Object.create(person);
per1.name = 'www';
per1.age = '18'; // 增强
per1.friends.push('xxx');
console.log(per1); // {name: "www", age: "18"}
console.log(per2); // {} 纯洁的新对象
console.log(per1.name, per1.friends); // www, ["bb", "jj", "hh", "yy", "nn", "xxx"]
console.log(per2.name, per2.friends); // xql, ["bb", "jj", "hh", "yy", "nn", "xxx"]
- 优缺点：
优点： 从已有对象衍生新对象，不需要创建自定义类型（更像是对象复制，而不是继承。）
缺点：和原型链继承一样
- 原型引用属性会被所有实例共享；
- 无法实现代码复用；
寄生式继承（穿个马甲）
function getSubObject(obj) {
let clone = Object.create(obj);
clone.attr1 = 1;
clone.attr2 = 2;
// ...
return clone;
}
let person = {
name: 'xql';
friends: ['nn'];
}
let per1 = getSubObject(person);
console.log(per1); // {attr1: 1, attr2: 2}
- 实现的本质： 给原型式继承穿了个马甲而已，看起来比较像继承。同样是基于某个对象或某个信息创建一个对象，然后增强对象，最后返回对象。
- 优缺点：
同原型式继承。
ps: 有缺陷的寄生式继承 + 不完美的组合继承 = 完美的寄生组合式继承
寄生组合继承
组合继承最大的问题是，无论什么情况下，都会调用两次父类构造函数：一次是在创建子类原型时（实现方法的继承）；另一次是在子类构造函数内部（实现属性的继承）。（第二次子类实例调用构造函数，会覆盖掉第一次子类原型调用构造函数生成的实例属性，使子类原型上的父类构造函数执行生成的实例属性永远排不上用场，占用了多余的内存）。
怎么解决呢？
- 所谓寄生组合继承的实现本质：不必为了指定子类构造函数的原型而调用父类构造函数，我们所需要的无非就是父类构造函数的原型的一个副本而已。为了继承父类实例的方法（父类构造函数的原型上的方法），使用寄生式继承来继承父类构造函数的原型。
/**
* @param {function} 子类构造函数
* @param {function} 父类构造函数
*/
function inherit(SubType, SuperType) {
let proto = Object.create(SuperType.prototype);
// let proto = object(SuperType.prototype);
// object函数见上 原型式继承
proto.constructor = SubType;
SubType.prototype = proto;
}
function Super(name) {
this.name = name;
this.friends = ['nnn'];
}
Super.prototype.fun1 = function() {}
Super.prototype.fun2 = function() {}
// ...
function Sub(name) {
this.hobby = 'hhh';
Super.call(this, name);
}
inherit(Sub, Super); // 核心
Sub.prototype.fun11 = function() {}
// ...
let sub1 = new Sub('xql');
console.log(sub1);
console.log(sub1)
- 优缺点：
优点：同组合继承。但解决了组合继承的缺点，只调用了一次父类构造函数，避免了在子类构造函数的原型上创建不必要的、多余的属性。
缺点：理论上没有。
