JS 实现继承的方法有：
1.原型链继承
2.构造函数继承
3.组合继承（原型链继承 + 构造函数继承）
4.原型式继承（对象的浅复制）
5.寄生式继承
6.寄生组合继承
（一）原型链继承
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。
优点：
1.简单、易于实现
缺点：
1.包含引用类型的原型属性会被所有实例共享；（这也是为什么要在构造函数中定义属性，而不是在原型对象中定义属性的原因）如例子中实例sub1修改arr后，也会改变实例sub2.arr的值；
2.创建子类实例时，无法向父类构造函数传参。实际上，应该是无法在不影响所有实例对象的情况下，给父类的构造函数传参。
（二）构造函数继承
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']
实现的本质：借用父类的构造函数来增强子类实例。等于是把父类的实例属性复制了一份传递给子类实例（完全没有用到原型）
优点：
1.解决了子类实例共享父类引用属性的问题；
2.创建子类实例时，可以向父类构造函数传参；
3.可以实现多继承（call多个父类对象）。
缺点：
1.方法都在构造函数中定义，函数复用也就无从谈起了。每个子类都有父类实例属性副本。每个子类实例都持有父类的所有函数方法，太多了就会影响性能，内存爆炸；
2.只能继承父类构造函数内的属性方法，不能继承原型对象上的属性方法；
3.实例并不是父类的实例，只是子类的实例。
（三）组合继承（原型链继承 + 构造函数继承）
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);
实现的本质：把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点（使用原型链实现对原型属性和方法的继承（一般不在原型上写引用属性），而通过借用构造函数来实现对实例属性的继承）。即在原型上定义方法实现了函数复用，又能保证每个实例都有它自己的属性。
通过Super.call(this);继承父类的基本属性和引用属性并保留能传参的优点；
通过Sub.prototype = new Super();继承父类函数，实现函数复用。
注：组合继承需要修复构造函数的指向。因为重写了原型对象Sub.prototype，这里Sub.prototype.constructor便指向了构造函数Super，需要修复！！！
Sub.prototype = new Super();
Sub.prototype.constructor = Sub;
优点：
1.函数可复用；
2.可以继承实例属性/方法，也可以继承原型属性/方法；
3.既是子类的实例，也是父类的实例；
4.不存在引用属性共享问题；
5.可传参。
缺点：
1.子类原型上有一份多余的父类实例属性；因为父类构造函数被调用了两次，生成了两份；而子类实例上的那一份屏蔽了子类原型上的。又是内存浪费。
第一次Super.call(this);语句从父类拷贝了一份父类实例属性给子类作为子类的实例属性;
第二次Sub.prototype = new Super();创建父类实例作为子类原型，此时这个父类实例就又有了一份实例属性，但这份会被第一次拷贝来的实例属性屏蔽掉，所以多余。
即子类原型上的这份父类实例永远用不到，被子类实例上的父类实例覆盖掉了。
（四）原型式继承（对象的浅复制）
function objectCreate(obj){
function F(){}
F.prototype = obj
return new F()
}
优点：
1.从已有对象衍生新对象，不需要创建自定义类型（更像是对象复制，而不是继承）
缺点：
1.原型引用属性会被所有实例共享；
2.无法实现代码复用。
（五）寄生式继承
function getSubObject(obj) {
let clone = Object.create(obj); //创建新对象，obj的内容属性放到新对象的隐式原型上了，不继承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}
实现的本质：跟原型式继承类似，看起来比较像继承。同样是基于某个对象或某个信息创建一个对象，然后增强对象，最后返回对象。
优缺点：同原型式继承。
（六）寄生组合继承
组合继承最大的问题是，无论什么情况下，都会调用两次父类构造函数：
一次是在创建子类原型时（实现方法的继承）；
另一次是在子类构造函数内部（实现属性的继承）。
（第二次子类实例调用构造函数，会覆盖掉第一次子类原型调用构造函数生成的实例属性，使子类原型上的父类构造函数执行生成的实例属性永远排不上用场，占用了多余的内存）。
解决办法：
寄生组合继承的实现本质：不必为了指定子类构造函数的原型而调用父类构造函数，我们所需要的无非就是父类构造函数的原型的一个副本而已。为了继承父类实例的方法（父类构造函数的原型上的方法），使用寄生式继承来继承父类构造函数的原型。
function Super(name){
this.name = name;
this.friend = ['nn'];
}
Super.prototype.fun1 = function () {}
function Sub(name){
this.hobby = 'hhh'
Super.call(this, name);
}
Sub.prototype = Object.create(Super.prototype)
Sub.prototype.constructor = Sub
let sub1 = new Sub('qweq')
console.log(sub1)
优点：
同组合继承。但解决了组合继承的缺点，只调用了一次父类构造函数，避免了在子类构造函数的原型上创建不必要的、多余的属性。
缺点：
理论上没有。
