共计 3286 个字符，预计需要花费 9 分钟才能阅读完成。
最近在阅读《js 权威指南》的继承这一章，对于组合模式和寄生组合模式的区别有点混淆，在多次重读以及尝试之后，得到一些心得。
组合模式继承
结合了构造函数继承时可以为每个属性重新初始化，构造一个副本的优点，以及原型链继承时一次定义处处共享的优点。
下面看具体的例子
/*js*/
function SuperType(name) {
this.name = name
this.color = [‘red’,’blue’,’green’]
}
SuperType.prototype.getSuperName = function () { // 在原型链上而不是构造函数里面添加方法，是为了进行方法复用
console.log(this.name)
}
function SubType(name, age) {
SuperType.call(this,name) // 在子类构造函数里面调用父类构造函数，创建一个新的对象
this.age = age
}
SubType.prototype.getSubAge = function () { // 子类特有的方法
console.log(this.age)
}
var instance1 = new SubType(‘Maria’,24)
instance1.color.push(‘black’)
console.log(instance1.color) // [‘red’,’blue’,’green’,’black’]
var instance2 = new SubType(‘Jack’,33)
console.log(instance2.color) // [‘red’,’blue’,’green’]
可以看到即使父类有引用对象，子类两个实例的对象之间也不会互相影响。
这个例子最大程度上地优化了代码，将方法放在原型链上，而通过子类构造函数里的 SuperType.call()，为每个子类对象初始化了父类对象里面的属性，这些属性就变成了子类独享的。组合继承成为 js 最常用的继承模式。
但组合模式也不是没有缺点。它的缺点在于：
无论在什么情况下，都会调用两次超类型构造函数，一次是在创建子类型原型的时候，另一次是在子类型构造函数的内部。
但令我百思不得其解的是，从上面给出的例子来看，组合继承并没有调用两次超类型构造函数。当实例化 SubType 的时候有通过 SuperType.call() 调用一次过一次 SuperType。同时，instance1 和 instance2 都是 SubType 对象。那么，第二次调用从何而来？
其实，上面的例子是并不完整的。两个实例实际上只继承了超类型的属性，却没有继承超类型的方法。
我们在实例化 SubType 的时候，实际上就自动给实例化对象创建了一个新的原型对象，这个原型对象跟超类型的原型对象没有什么关系。所以 SubType 并没有继承 getSuperName() 方法。
下面为子类型继承父类型原型的例子：
/*js*/
function SuperType(name) {
this.name = name
this.color = [‘red’,’blue’,’green’]
}
SuperType.prototype.getSuperName = function () {
console.log(this.name)
}
function SubType(name, age) {
SuperType.call(this,name)
this.age = age
}
SubType.prototype = new SuperType()
SubType.prototype.constructor = SubType
SubType.prototype.getSubAge = function () {
console.log(this.age)
}
var instance1 = new SubType()
instance1.color.push(‘black’)
console.log(instance1.color)
var instance2 = new SubType()
console.log(instance2.color)
在这个例子中，我们来看一下 instance1 的组成：
在第一次调用 SuperType 的时候，SubType.prototype 会得到两个属性：color 和 name，它们也是 SuperType 的实例属性，不过现在位于 SubType 的原型上面。
在实例化 SubType 时调用了第二次 SuperType, 这个时候 SubType 实例对象多了两个 name 和 color 的属性，这两个属性属于实例属性，会覆盖掉在 SubType 原型对象的属性。
为了解决组合继承这种无论如何都会调用两次的问题，便可以引用寄生组合式继承。
寄生组合式继承
寄生组合式继承是在原型式继承的基础上做的。
原型式继承时道格拉斯·克罗克福德在 2006 年提出来的。主要目的是可以基于已有的对象创建新的对象，而不必因此创建自定义类型。
具体代码如下：
function object(o) {
function F(){}
F.prototype = o
return new F()
}
通过将 o 赋给 F 的原型，再返回一个原型为 o 的新对象。
而寄生组合式继承在此基础上的代码为：
function inheritPrototype(superType,subType){
var prototype = object(superType.prototype) // 首先返回了一个原型是 superType 的原型的新对象
prototype.constructor = subType // prototype 的 constructor 从 superType 变成 subType
subType.protoType = prototype // 将拥有指向 SubType 函数的 constructor，以及 superType 对象属性的新对象，赋给 subType 的原型
}
function SuperType(name) {
this.name = name
this.color = [‘red’,’blue’,’green’]
}
SuperType.prototype.getSuperName = function () {
console.log(this.name)
}
function SubType(name, age) {
SuperType.call(this,name)
this.age = age
}
inheritPrototype(SuperType,SubType) // 调用 inheritPrototype 方法替换子类的原型
SubType.prototype.getSubAge = function () {
console.log(this.age)
}
var instance1 = new SubType(‘Maria’,24)
instance1.color.push(‘black’)
console.log(instance1.color) // [‘red’,’blue’,’green’,’black’]
var instance2 = new SubType(‘Jack’,33)
console.log(instance2.color) // [‘red’,’blue’,’green’]
寄生组合式继承在组合继承的基础上做了改进，只需要调用一次 inheritPrototype 函数，就可以把 SuperType 对象的原型属性继承给 SubType 对象，同时 SubType 实例的原型对象依然指向 SubType 函数。
ECMAScript 把 object() 做了改进，变成了 Object.create() 方法，所以 inheritPrototype 方法的第一行可以写成：
var prototype = Object.create(SuperType.prototype)
对比组合模式和寄生组合模式：
组合模式：为每个属性重新初始化，构造一个副本。但是每次实例化都会调用两次 SuperType，降低性能。
寄生组合模式：在组合模式的基础上，通过一次性将子对象的原型替换成父对象的原型，同时原型指向子对象。每次初始化对象就只调用一次 SuperType。可以提升效率。
