浅析JS继承方法

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)

优点：

同组合继承。但解决了组合继承的缺点，只调用了一次父类构造函数，避免了在子类构造函数的原型上创建不必要的、多余的属性。

缺点：

理论上没有。