008 实现继承的几种方式

前面总结了创建对象的几种方式，本文将再总结一些实现继承的方式。无论是创建对象，还是继承，都离不开一个东西：原型。首先来看原型链模式。

原型链模式

首先，我们有两个构造函数：Car 和 Ford：

// Car 构造函数（类）
function Car( brand ){ this.brand = brand }
Car.prototype.getBrand = function(){ console.log(this.brand) }

// Ford 构造函数（类）
function Ford(model ){ this.model = model }
Ford.prototype.getModel = function(){ console.log(this.model) }

现在，我们想让 Ford 类来继承 Car 类，该怎么做呢？要解决这个问题，首先需要知道继承的作用是什么。
继承的作用就是：子类的实例可以调用父类的方法。也就是说，之所以要让 Ford 类继承 Car 类，目的是为了让 Ford 类的实例可以调用 Car 中的方法。
我们知道 JavaScript 中属性的查找是按照原型链一层一层查找的，Ford 实例的原型是 Ford 的 prototype 属性，在查找 Ford 实例的属性时，首先在其自身上进行查找，如果找不到，就去其原型也就是 Ford 的 prototype 上查找。如果在 Ford 的 prototype 上也查找不到呢？这时我们期望可以在 Car 的 prototype 上查找，这也是我们继承的最终目的。
因此，要实现继承，只需将子类（Ford）的 prototype 和父类（Car）的 prototype 关联起来，将父类（Car）的 prototype 作为子类（Ford）的 prototype 的原型就可以了。
现在，我们的目的就变成：将父类的 prototype 作为子类 prototype 的原型，实现了这个，也就实现了继承。
如何将父类的 prototype 作为子类的 prototype 的原型呢？我们来看看什么样的对象是以父类的 prototype 作为原型的，很明显，就是父类的实例。
因此，我们只需将子类（Ford）的 prototype 设置为父类（Car）的一个实例，问题就解决了。子类若想再添加自己的属性和方法，只需在这个父类实例上进行添加就可以了，不会影响到父类的实现。

// Car 构造函数（类）
function Car( brand ){ this.brand = brand }
Car.prototype.getBrand = function(){ console.log(this.brand) }

// Ford 构造函数（类）
function Ford(model ){ this.model = model }
// 将 Ford 的 prototype 设置为 Car 的实例
Ford.prototype = new Car("ford")
Ford.prototype.getModel = function(){ console.log(this.model) }

如果还有更深层次的继承，继续进行原型对象的赋值就行了。
这种继承的方式会造成子类 prototype 的 constructor 指向父类的构造函数，因此可以进行修复：

Ford.prototype = new Car("ford")
Ford.prototype.constructor = Ford

上面花一大段文字介绍了原型链继承的实现方式，是因为原型链理解起来确实有一点烧脑的，因此我将自己的分析过程写出来了，供大家参考。

构造函数继承

原型链继承的问题在于：如果原型链上有引用类型数据，就是一个很大的陷阱。
还记得吗？在使用原型模式创建对象时，我们可以通过构造函数为每一个对象单独赋值来解决引用类型的问题。因此这里也可以借用构造函数进行继承。

// 父类
function Car( brand ){ 
  this.brand = brand
  this.getBrand = function(){ console.log(this.brand) } 
}
// 子类
function Ford( brand,model ){
  Car.apply(this,brand)
  this.model = model
  this.getModel = function(){ console.log(this.model) }
}

这里有个注意点，就是子类自身的初始化需要放在 apply 函数执行的下面，这样可以避免父类的同名属性对子类相同属性进行覆盖。

组合继承

单独使用构造函数进行继承也是有问题的，比如代码无法复用和资源浪费，因此这里可以结合构造函数继承和原型继承使用。

// 父类
function Car(brand,colors){
  this.brand = brand
  this.colors = colors
}
Car.prototype.getBrand = ...
Car.prototype.getColors = ...
// 子类
function Ford(brand,colors,model){
  Car.apply(this,[brand,colors])
  this.model = model
}
Ford.prototype = new Car()
Ford.prototype.getModel = ...

或许你注意到了，我们在将父类的实例赋值给子类的 prototype 时，没有在实例化时传入参数，这是子类的 prototype 上就有了两个值为 undefined 的属性（brand 和 colors）。事实上，这里是否传入参数都不会对子类创建的对象有任何影响，因为子类在实例化时，会在构造函数内部再次调用父类的构造函数，给创建的实例添加相应的属性。除非我们删除子类实例的 brand 和 colors 属性，否则子类的 prototype 上的两个属性是不会起到任何作用的，无非就是增加了两个“多余”的属性。
组合继承结合了原型链继承和构造函数继承的优点，摒弃了缺点，是 JavaScript 中最常用的继承模式。

原型式继承

这种继承并没有一个明确的构造函数，而是通过一个对象，创建出一个以该对象为原型的对象。

function extend(o){
  function F(){}
  F.prototype = o
  return new F()
}

F 是一个临时函数，在 extend 函数执行时，创建了一个临时函数 F，并将 F 的 prototype 赋值为传入的对象，最后返回一个 F 的实例。每次调用 extend 函数时都会声明一个临时函数 F，并进行一次 prototype 赋值。
ES5 中新增了一个 Object.create() 方法，这个方法我们在前面也介绍过，使用此方法也可以基于某个对象创建其的一个实例，是对上面的 extend 函数的一种规范性实现。
原型式继承的使用范围是：在没有必要创建构造函数，只是想让一个对象和另一个对象保持类似的情况下，可以使用这种方法。

寄生式继承

寄生式继承依赖于上面的原型式继承，然后进行一些初始化操作。

function extend(o){
  let tmpO = Object.create(o)
  tmp.sayHi = ...
  return tmpO
}

寄生式继承相比于原型式继承，就增加了这么点东西。如果这样写，就更明显了：

function extend(o){
  function F(){}
  F.prototype = o
  F.prototype.sayHi = ...  
  return new F()
}

二者是不是很相似呢？

寄生组合式继承

前面提到过，组合式继承是最常用的继承方式，但也有一些小缺点，比如在继承过程中父类构造函数会被调用两次：

• 一次在显式创建父类实例，赋值给子类 prototype 时调用
• 一次在子类实例化时，在子类内部通过 apply 调用

于是大神们将组合模式和寄生模式进行了一个小小的结合，解决了这个问题。

// 父类
function Car( brand,colors ){
  this.brand = brand
  this.colors = colors
}
Car.prototype.getBrand = ...
Car.ptototype.getColors = ...

// 子类
function Ford( brand,colors, model){
  Car.apply(this,[ brand,colors] )
}

// extend 函数
function extend(subClass,superClass){
  subClass.prototype = Object.create( superClass.prototype )
}

// 调用 extend 函数
extend(Ford,Car)
// 为子类的 ```prototype``` 添加方法
Ford.prototype.getModel = ...

可见，利用这种方式解决了多次调用父类构造函数的问题，但是也多出了很多代码，没有组合式继承使用方便，个人不推荐使用。

总结

本文总结了一些常见的继承方式，细心的你或许已经发现了，这些继承的方式其实很像我们提到的创建对象的几种模式，其实事实也是如此，不论是这里的继承还是前面说到的创建对象，都只是对类或者对象进行一些扩展，而扩展的方式都是类似的：使用原型进行扩展或者使用构造函数进行扩展。因此，它们看起来是如此的相似。
个人认为，面向对象程序设计这章内容，是《JavaScript 高级程序设计》中最精彩的一章了，因此也用了很多篇幅来总结，内容很多也很精华，应当慢慢消化吸收才是。
还是那句话，当你忘了这其中的某一块内容，还记得常回来看看~

完。