深入之继承多种方式与优缺点

1、原型链继承

function Parent(){
  this.name = 'cegz';
}
Parent.prototype.getName = function(){
  console.log(this.name);
}
function Child(){}
Child.prototype = new Child();
let child = new Child();
child.getName()  // cegz

问题：

• 1、引用类型的属性被所有实例共享：例如

function Parent(){
  this.animal = ['cat','fish'];
}
function Child(){}
Child.prototype = new Parent();
let child1 = new Child();
let child2 = new Child();
child1.animal.push('dog');
console.log(child1.animal);  // ['car','fish','dog']
console.log(child2.animal);  // ['car','fish','dog']

• 2、在创建 Child 的实例时，不能向Parent传参

2、借用构造函数(经典继承)

function Parent(){
  this.animal = ['cat','fish'];
}
function Child(){
  Parent.call(this);
}
let child1 = new Child();
let child2 = new Child();
child1.animal.push('dog');
console.log(child1.animal);  // ['cat','fish','dog']
console.log(child2.animal);  // ['cat','fish']

优点：
1、避免了引用类型属性被所有实例共享
2、可以在Child中向Parent传参

function Parent(name){
    this.name = name;
}
function Child(name){
    Parent.call(this,name);
}
let child1 = new Child('cyl');
let child2 = new Child('cegz');
console.log(child1.name);  // cyl
console.log(child2.name);  // cegz

缺点：
1、方法都在构造函数中定义，，每次创建实例都会创建一次方法
2、获取不到原型上的成员属性

3、组合继承(原型链继承和经典继承)

function Parent(name){
    this.name = name;
    this.animal = ['fish','cat','dog'];
}
Parent.prototype.getName = function(){
    console.log(this.name);
}
function Child(name,age){
    Parent.call(this,name);
    this.age = age;
}
Child.prototype = new Parent();
Child.prototype.constructor = Child;

let child1 = new Child('cyl',18);
let child2 = new Child('cegz',20);
child1.animal.push('duck');
child1.getName();  // cyl
child2.getName();  // cegz

console.log(child1.name);  // cyl
console.log(child1.age);  // 18
console.log(child1.animal);  // ["fish", "cat", "dog", "duck"]

console.log(child2.name);  // cegz
console.log(child2.age);  // 20
console.log(child2.animal);  // ["fish", "cat", "dog"]

优点：结合原型链和构造函数的优点，最常用的继承方式
缺点：会调用两次父构造函数，每new一次，都会执行一次new 的构造函数，我们打印child1对象，会发现Child.prototype 和 child1 都有一个属性为animal

Child.prototype = new Parent();  // 第一次调用
let child1 = new Child('cyl',18);  // 第二次调用

4、原型式继承

function Parent(){
    this.name = 'cyl'
}
Parent.prototype.animal = ['fish','cat'];
function Child(){}
Child.prototype = Parent.prototype;
let child1 = new Child();
let child2 = new Child();
child1.animal.push('dog');
console.log(child1.name,child1.animal); //undefined ["fish", "cat", "dog"]
console.log(child2.name,child2.animal); //undefined ["fish", "cat", "dog"]

缺点：
1、原型上的属性如果是引用类型，该属性会在实例之间实现共享
2、只能继承原型对象成员，不能继承父构造函数实例成员

5、寄生式继承

创建一个仅用于封装继承过程的函数，该函数在内部以某种形式来做增强对象，最后返回对象。

function createObj(o){
  let clone = Object.create(o);  //调用函数创建一个新对象
  clone.sayName = function(){  // 以某种方式来增强该对象
    console.log('hi');
  }
  return clone           // 返回该对象
}

缺点：跟借用构造函数一样，每次创建对象都会创建一次方法

6、寄生组合式继承

组合继承最大的缺点是会调用两次父构造函数，如果不使用Child.prototype = new Parent()，而是间接的让Child.prototype访问到Parent.prototype,并且避免实例对象child和构造函数原型Child.prototype拥有重复的属性
看看如何实现：

function Parent(name){
    this.name = name;
    this.animal = ['cat','fish','dog'];
}
Parent.prototype.getName = function(){
    console.log(this.name);
}
function Child(name,age){
    Parent.call(this,name);
    this.age = age;
}
//关键的三步
let F = function(){};
F.prototype = Parent.prototype;
Child.prototype = new F();

let child = new Child('cyl',18);
console.log(child);  // 只有child实例上才会有Parent继承的animal

最后封装一个这个继承方法：

function object(o){
  function F() {}
  F.prototype = 0;
  return new F();
}

function prototype(child,parent){
  let prototype = object(child,parent);
  prototype.constructor = child;
  child.prototype = prototype;
}
//使用
prototype(Child,Parent);

完整实例：

function Parent(name){
    this.name = name;
    this.animal = ['cat','fish'];
}
Parent.prototype.getName = function(){
    console.log(this.name);
}
function Child(name,age){
    Parent.call(this,name);
    this.age = age;
}

function object(o){
    function F(){};
    F.prototype = o;
    return new F();
}
function prototype(child,parent){
    var prototype = object(parent.prototype);
    prototype.constructor = child;
    child.prototype = prototype;
}
prototype(Child,Parent);

let child1 = new Child('cyl',18);
let child2 = new Child('cegz',20);

child1.getName();  // 'cyl'
child2.getName();  // 'cegz'
child1.animal.push('dog');
console.log(child1.animal);  // ["cat", "fish", "dog"]
console.log(child2.animal);  // ["cat", "fish"]

这种方式的高效率体现它只调用了一次Parent 构造函数，并且避免了在Parent.prototype上面创建不必要、多余的属性，所以寄生组合继承是引用类型最理想的继承范式。

转自：https://github.com/mqyqingfeng/Blog/issues/16