JS高程笔记 - 继承

组合继承

组合继承(combination inheritance),有时候也叫作伪经典继承,指的是将原型链和借用构造函数的技术组合到一块,从而发挥两者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方法的继承,而经过借用构造函数来实现对实例属性的继承。这样,既经过在原型上定义方法实现了函数复用,又可以保证每一个实例都有它本身的属性。下面来看一个例子：

function SuperType (name) {
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
    alert(this.name);
};

function SubType (name, age) {
    SuperType.call(this, name); //继承属性
    this.age = age;
}
SubType.prototype = new SuperType(); //继承方法
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function () {
    alert(this.age);
};

var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
instance1.sayName();     //"Nicholas";
instance1.sayAge();      //29

var instance2 = new SubType("Greg", 27);
alert(instance2.colors); //"red,blue,green"
instance2.sayName();     //"Greg";
instance2.sayAge();      //27

在这个例子中,SuperType 构造函数定义了两个属性:name 和 colors。SuperType 的原型定义了一个方法 sayName()。SubType 构造函数在调用 SuperType 构造函数时传入了 name 参数,紧接着又定义了它本身的属性 age。而后,将 SuperType 的实例赋值给 SubType 的原型,而后又在该新原型上定义了方法 sayAge()。这样一来,就可让两个不一样的 SubType 实例既分别拥有本身属性——包括 colors 属性,又可使用相同的方法了。组合继承避免了原型链和借用构造函数的缺陷,融合了它们的优势,成为 JavaScript 中最经常使用的继承模式。并且,instanceof和 isPrototypeOf()也可以用于识别基于组合继承建立的对象。

寄生组合式继承

前面说过,组合继承是 JavaScript 最经常使用的继承模式;不过,它也有本身的不足。组合继承最大的问题就是不管什么状况下,都会调用两次超类型构造函数:一次是在建立子类型原型的时候,另外一次是在子类型构造函数内部。没错,子类型最终会包含超类型对象的所有实例属性,但咱们不得不在调用子类型构造函数时重写这些属性。再来看一看下面组合继承的例子。

function SuperType (name) {
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function () {
    alert(this.name);
};

function SubType (name, age) {
    SuperType.call(this, name); //第二次调用 SuperType()
    this.age = age;
}
SubType.prototype = new SuperType(); //第一次调用 SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function () {
    alert(this.age);
};

在第一次调用 SuperType 构造函数时,SubType.prototype 会获得两个属性:name 和 colors;它们都是 SuperType 的实例属性,只不过如今位于 SubType 的原型中。当调用 SubType 构造函数时,又会调用一次 SuperType 构造函数,这一次又在新对象上建立了实例属性 name 和 colors。因而,这两个属性就屏蔽了原型中的两个同名属性。

好在咱们已经找到了解决这个问题方法——寄生组合式继承。所谓寄生组合式继承,即经过借用构造函数来继承属性,经过原型链的混成形式来继承方法。其背后的基本思路是:没必要为了指定子类型的原型而调用超类型的构造函数,咱们所须要的无非就是超类型原型的一个副本而已。本质上,就是使用寄生式继承来继承超类型的原型,而后再将结果指定给子类型的原型。寄生组合式继承的基本模式以下所示。

function inheritPrototype (subType, superType) {
    var prototype = object(superType.prototype);  //建立对象
    prototype.constructor = subType;              //加强对象
    subType.prototype = prototype;                //指定对象
}

这个示例中的 inheritPrototype()函数实现了寄生组合式继承的最简单形式。这个函数接收两个参数:子类型构造函数和超类型构造函数。在函数内部,第一步是建立超类型原型的一个副本。第二步是为建立的副本添加 constructor 属性,从而弥补因重写原型而失去的默认的 constructor 属性。最后一步,将新建立的对象(即副本)赋值给子类型的原型。这样,咱们就能够用调用 inherit-Prototype()函数的语句,去替换前面例子中为子类型原型赋值的语句了,例如:

function SuperType (name) {
    this.name = name; 
    this.colors = ["red", "blue", "green"]; 
} 
SuperType.prototype.sayName = function () {
    alert(this.name); 
}; 

function SubType (name, age) {
    SuperType.call(this, name);
    this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function () {
    alert(this.age);
};

这个例子的高效率体如今它只调用了一次 SuperType 构造函数,而且所以避免了在 SubType.prototype 上面建立没必要要的、多余的属性。与此同时,原型链还能保持不变;所以,还可以正常使用instanceof 和 isPrototypeOf()。开发人员广泛认为寄生组合式继承是引用类型最理想的继承范式。