继承是OO语言中的一个最为人津津乐道的概念。

许多OO语言都支持两种继承方式：接口继承和实现继承。

接口继承只继承方法签名，而实现继承则继承实际的方法。

如前所述，由于函数没有签名，在ES中无法实现接口继承。

ES只支持实现继承，而且其实现继承主要是依靠原型链来实现的。

 

原型链

ES中描述了原型链的概念，并将原型链作为实现继承的主要方法。

其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。

构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。

那么，假如我们让原型对象等于另一个类型的实例，结果会怎么样呢？

显然，此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中也包含着一个指向另一个构造函数的指针。

假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实例与原型的链条。

这就是所谓原型链的基本概念。

 

实现原型链有一种基本模式：

// 第一个类型
function SuperType() {
    this.property = true;
}
SuperType.prototype.getSuperValue = function() {
    return this.property;
};

// 第二个类型
function SubType() {
    this.subproperty = false;
}

// 继承
SubType.prototype = new SuperType(); 

// 第二个类型自己的方法
SubType.prototype.getSubValue = function() {
    return this.subproperty;
};

// 使用继承来的方法
var instance = new SubType();
alert(instance.getSuperValue()); // true

 

实现的本质是重写原型对象，代之以一个新类型的实例。

换句话说，原来存在于SuperType的实例中的所有属性和方法，也存在于SubType.prototype中了。

 

 此外，要注意instance.constructor现在指向的是SuperTyppe，这是因为原来SubType.prototype中的constructor被重写了的缘故。

（实际上，不是SubType的原型的constructor属性被重写了，二是SubType的原型指向了另一个对象SuperType的原型，而这个原型对象的constructor属性指向的是SuperType）

 

通过实现原型链，本质上扩展了本章前面介绍的原型搜索机制。

当以读取模式访问一个实例属性时，首先会在实例中搜索该属性。

如果没有找到该属性，则会继续搜索实例的原型。

在通过原型链实现继承的情况下，搜索过程就得以沿着原型链继续向上。

在找不到属性或方法的情况下，搜索过程总是要一环一环地前行到原型链末端才会停下来。

 

---

 

别忘记默认的原型

事实上，前面例子中展示的原型链还少一环。

我们知道，所有引用类型默认都继承了Object，而这个继承也是通过原型链实现的。

所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。

这也正是所有自定义类型都会继承toString()、valueOf()等默认方法的根本原因。

当调用instance.toString()时，实际上调用的是保存在Object.prototype中的那个方法。

 

---

 

确定原型和实例的关系

可以通过两种方式来确定原型和实例之间的关系。

第一种方式是用instanceof操作符，只要用这个操作符来测试实例与原型链中出现过的构造函数，结果就会返回true。

alert(instance instanceof Object); // true
alert(instance instanceof SuperType); // true
alert(instance instanceof SubType); // true

 

第二种方式是使用isPrototypeOf()方法。

同样，只要是原型链中出现过的原型，都可以时候是该原型链所派生的实例的原型，因此isPrototypeOf()方法也会返回true。

alert(Object.prototype.isPrototypeOf(instance)); // true
alert(SuperType.prototype.isPrototypeOf(instance)); // true
alert(SubType.prototype.isPrototypeOf(instance)); // true

 

---

 

谨慎地定义方法

子类型有时候需要重写超类型中的某个方法，或者需要添加超类型中不存在的某个方法。

但不管怎样，给原型添加方法的代码一定要放在替换原型的语句之后。

// 添加新方法
SubType.prototype.getSubValue = function() {
    return this.subproperty;
}:
// 重写超类型中的方法
SubType.prototype.getSuperValue = function() {
    return false;
};

第二个方法getSuperValue()是原型链中已经存在的一个方法，但重写这个方法将会屏蔽原来的那个方法。

换句话说，当通过SubType的实例调用getSuperVaule()时，调用的就是这个重新定义的方法；但通过SuperType的实例调用getSuperValue()时，还会继续调用原来的那个方法。

这里要格外注意的是，必须在用SuperType的实例替换原型之后，再定义这两个方法。

 

通过原型链实现继承时，不能使用对象字面量创建原型方法，因为这样做会重写原型链。

 

---

 

原型链的问题

原型链虽然很强大，可以用它来实现继承，但它也存在一些问题。

其中，最主要的问题来自包含引用类型值的原型。

前面介绍过包含引用类型值的原型属性会被所有实例共享；而这也正是为什么要在构造函数中，而不是在原型对象中定义属性的原因。

在通过原型来实现继承时，原型实际上会变成另一个类型的实例。

于是，原先的实例属性也就顺理成章地变成了现在的原型属性。

function SuperType() {
    this.colors = ['red', 'blue', 'green'];
}
function SubType() {}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push('black');
alert(instance1.colors); // 'red, blue, green, black'
instance2.colors.push('black');
alert(instance2.colors); // 'red, blue, green, black'

 

原型链的第二个问题是：在创建子类型的实例时，不能向超类型的构造函数中传递参数。

实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。

有鉴于此，再加上前面刚刚讨论过的由于原型中包含引用类型值所带来的问题，实践中很少会单独使用原型链。

 

---

 

借用构造函数

在解决原型中包含引用类型值所带来问题的过程中，开发人员开始使用一种叫做借用构造函数的技术，有时候也叫做伪造对象或经典继承。

这种技术的基本思想相当简单，即在子类型构造函数的内部调用超类型构造函数。

别忘了，函数只不过是在特定环境中执行代码的对象，因此通过使用apply()和call()方法也可以在新创建的对象上执行构造函数。

function SuperType() {
    this.colors = ['red', 'blue', 'green'];
}
function SubType() {
    // 继承SuperType
    SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push('black');
alert(instance1.colors); // 'red,blue,green,black'
var instance2 = new SubType();
alert(instance2.colors); // 'red,blue,green'

代码中加背景的那一会代码借调了超类型的构造函数。

通过使用call()方法或apply()方法，我们实际上是在未来将要新创建的SubType实例的环境下调用了SuperType构造函数。

这样一来，就会在新SubType对象上执行SuperType()函数中定义的所有对象初始化代码。

结果，SubType的每个实例就都会具有自己的colors属性的副本了。

 

传递参数

相对于原型链而已，借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函数传递参数。

function SubType() {
    // 继承了SuperType，同时还传递了参数
    SuperType.call(this, 'Nicholas');
    // 实例属性
    this.age = 29;
}

 

借用构造函数的问题

如果仅仅是借用构造函数，那么将无法避免构造函数模式存在的问题，方法都在构造函数中定义，因此函数复用就无从谈起了。

而且，在超类型的原型中定义的方法，对子类而言也是不可见的，结果所有类型都只能使用构造函数模式。

考虑到这些问题，借用构造函数的技术也是很少单独使用的。

 

---

 

组合继承

组合继承有时候也叫做伪经典继承，指的是将原型链和借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式。

其背后的思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。

这样，既通过在原型上定义方法实现了函数复用，又能够保证每个实例都有它自己的属性。

function SuperType(nam) {
    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.sayAge = function() {
    alert(this.age);
};
var instance1 = new SubTyoe('Nicholas', 29);
instance1.colors.push('black');
alert(instance1.colors); // 'red,blue,green,black'
instance1.sayName(); // 'Nicholas'
instance1.sayAge(); // 29
var instance2 = new SubTyoe('Greg', 27);
instance1.colors.push('black');
alert(instance2.colors); // 'red,blue,green'
instance2.sayName(); // 'Greg'
instance2.sayAge(); // 27

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，称为JS中最常用的继承模式。

而且，instanceof和isPrototypeOf()也能够用于识别基于组合继承创建的对象。

 

---

 

原型式继承

他的想法是借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。

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

var person = {
    name: 'Nicholas',
    friends: ['Shelby', 'Court', 'Van']
};
var anotherPerson = object(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Rob');
var yetAherPerson = object(person);
yetAherPerson .name = 'Linda';
yetAherPerson .friends.push('Barbie');
alert(person.friends); // 'Shelby,Court,Van,Rob,Barbie'

克罗克福德主张的这种原型式继承，要求你必须有一个对象可以作为另一个对象的基础。

如果有这么一个对象的话，可以把它传递给object()函数，然后再根据具体需求对得到的对象加以修改即可。

 

ES5通过新增Object.create()方法规范化了原型式继承。

这个方法接收两个参数：一个用作新对象原型的对象和一个新对象定义额外属性的对象。

在传入一个参数的情况下，Object.create()与object()方法的行为相同。

var person = {
    name: 'Nicholas',
    friends: ['Shelby', 'Court', 'Van']
};
var anotherPerson = Object.create(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Rob');
var yetAherPerson = Object.create(person);
yetAherPerson .name = 'Linda';
yetAherPerson .friends.push('Barbie');
alert(person.friends); // 'Shelby,Court,Van,Rob,Barbie'

 

Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同：每个属性都是通过自己的描述符定义的。

以这种方式指定的任何属性都会覆盖原型对象上的同名属性。

var person = {
    name: 'Nicholas',
    friends: ['Shelby', 'Court', 'Van']
};
var anotherPerson = Object.create(person, {
    name: {
        value: 'Greg'
    }
});
alert(anotherPerson.name); // 'Greg'

 

在没有必要兴师动众地创建构造函数，而只想让一个对象与另一个对象保持类似的情况下，原型式继承是完全可以胜任的。

不过别忘了，包含引用类型的属性始终都会共享相应的值，就像使用原型模式一样。

 

---

 

寄生式继承

寄生式继承是与原型式继承紧密相关的一种思路，并且同样也是由克罗克福德推而广之的。

寄生式继承的思路与寄生式构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再想真地是它做了所有工作一样返回对象。

function createAnother(original) {
    var clone = object(original); // 通过调用函数创建一个新对象
    clone.sayHi = function() {    // 以某种方式来增强这个对象
        alert('hi');
    };
    return clone; // 返回这个对象
}

var person = {
    name: 'Nicholas',
    friends: ['Shelby', 'Court', 'Van']
};
var anotherPerson = createAonther(person);
anotherPerson.sayHi();

在主要考虑对象而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式。

前面示范继承模式时使用的object()函数不是必需的；任何能够返回新对象的函数都适用于此模式。

 

---

 

寄生组合式继承

组合继承最大的问题就是无论什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部。

没错，子类型最终会包含超类型对象的全部实例属性，但我们不得不在调用子类型构造函数时重写这些属性。

 

所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。

其背后的基本思路是：不必为了指定类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。

本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

function inheriPrototype(subType, superType) {
    var prototype = object(superType.prototype); // 创建对象
    prototype.constructor = subType; // 增强对象
    subType.prototype = prototype; // 指定对象
}

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

开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。