js基础之实现继承的几种方式

js 实现继承的方式有：

1. 原型链继承；

2. 构造函数继承；

3. 组合继承（原型链继承 + 构造函数继承）（最常用）；
   （原型式继承；
   寄生式继承；）

4. 寄生组合继承 （最佳方式）

继承方式之间的联系

原型链继承

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']

1. 实现的本质是重写原型对象，代之以一个新类型的实例。Sub.prototype=new Super()；从而使子类得以继承父类的属性和方法。

注意这里sub1.constructor === Super为 true。(Sub.prototype.__proto__ === Super.prototype实例属性的查找自下往上进行查找的原则)

1. 优缺点：

优点：简单，易于实现。

缺点：

• 包含引用类型的原型属性会被所有实例共享；（这也是为什么要在构造函数中定义属性，而不是在原型对象中定义属性的原因）。从例子中可以看出实例 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']

1. 实现的本质：借用父类的构造函数来增强子类实例。等于是把父类的实例属性复制了一份给子类实例装上了（完全没有用到原型）

2. 优缺点：

优点：

• 解决了子类实例共享父类引用属性的问题；

• 创建子类实例时，可以向父类构造函数传参；

• 可以实现多继承（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);

1. 实现的本质：把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点。（使用原型链实现对原型属性和方法的继承（一般不在原型上写引用属性），而通过借用构造函数来实现对实例属性的继承）。即在原型上定义方法实现了函数复用，又能保证每个实例都有它自己的属性。

通过Super.call(this);继承父类的基本属性和引用属性并保留能传参的优点；
通过Sub.prototype = new Super();继承父类函数，实现函数复用。

• 注：组合继承需要修复构造函数的指向。因为重写了原型对象Sub.prototype，这里Sub.prototype.constructor便指向了构造函数Super，需要修复！！！

Sub.prototype = new Super(); 
Sub.prototype.constructor = Sub;

1. 优缺点：

优点：

• 函数可复用；

• 可以继承实例属性/方法，也可以继承原型属性/方法；

• 既是子类的实例，也是父类的实例；

• 不存在引用属性共享问题；

• 可传参

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"]

1. 优缺点：

优点： 从已有对象衍生新对象，不需要创建自定义类型（更像是对象复制，而不是继承。）
缺点：和原型链继承一样

• 原型引用属性会被所有实例共享；

• 无法实现代码复用；

寄生式继承（穿个马甲）

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}

1. 实现的本质： 给原型式继承穿了个马甲而已，看起来比较像继承。同样是基于某个对象或某个信息创建一个对象，然后增强对象，最后返回对象。

2. 优缺点：
   同原型式继承。

ps: 有缺陷的寄生式继承 + 不完美的组合继承 = 完美的寄生组合式继承

---

寄生组合继承

组合继承最大的问题是，无论什么情况下，都会调用两次父类构造函数：一次是在创建子类原型时（实现方法的继承）；另一次是在子类构造函数内部（实现属性的继承）。（第二次子类实例调用构造函数，会覆盖掉第一次子类原型调用构造函数生成的实例属性，使子类原型上的父类构造函数执行生成的实例属性永远排不上用场，占用了多余的内存）。

怎么解决呢？

1. 所谓寄生组合继承的实现本质：不必为了指定子类构造函数的原型而调用父类构造函数，我们所需要的无非就是父类构造函数的原型的一个副本而已。为了继承父类实例的方法（父类构造函数的原型上的方法），使用寄生式继承来继承父类构造函数的原型。

/**
* @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)

1. 优缺点：

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

作者：黎贝卡beka
链接：https://www.jianshu.com/p/bd5f1ce6511d