JavaScript 继承

继承是OO语言中的一个最为人津津乐道的概念。许多OO语言都支持两种继承方式：接口继承和实现继承。接口继承只继承方法签名，而实现继承则继承实际的方法。如前所述，由于函数没有签名，在ECMAScript中无法实现接口继承。ECMAScript只支持实现继承，而且其实现继承主要是依靠原型链来实现的。

原型链

ECMAScript中描述了原型链的概念，并将原型链作为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。简单回顾一下构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象内部指针。那么，假如我们让原型对象等于另一个类型的实例，结果会怎样呢？显然，此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中也包含着一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实例与原型的链条。这就是所谓原型链的基本概念。

实现原型链有一种基本模式，其代码大致如下。

example：

function SuperType(){
	this.property = true;
}

SuperType.prototype.getSuperValue = function(){
	return this.property;
};

function SubType(){
	this.subproperty = false;
}
//继承了 SuperType
SubType.prototype = new SuperType();

SubType.prototype.getSubValue = function(){
	return this.subproperty;
};

var instance = new SubType();
alert(instance.getSuperValue());   //true

以上代码定义了两个类型：SuperType和SubType。每个类型分别有一个属性和方法。它们的主要区别是SubType继承了SuperType，而继承是通过创建SuperType的实例，并将该实例赋给SubType.prototype实现的。实现的本质是重写原型对象，代之以一个新类型的实例。换句话说，原来存在于SuperType的实例中的所有属性和方法，现在也存在于SubType.prototype中了。在确立了继承关系之后，我们给SubType.prototype添加了一个方法，这样就在继承了SuperType的属性和方法的基础上有添加了一个新方法。

在上面的代码中，我们没有使用SubType默认提供的原型，而是给它们换了一个新原型；这个新原型就是SuperType的实例。于是，新原型不仅具有作为一个SuperType的实例所拥有的全部属性和方法，而且其内部还有一个指针，指向了SuperType的原型。最终结果就是这样的：instance指向SubType的原型，SubType的原型又指向SuperType的原型。getSuperValue（）方法任然还在SuperType.prototype中，但property则位于SubType.prototype中。这是因为property是一个实例属性，而getSuperValue（）则是一个原型方法。既然SubType.prototype现在是SuperType的实例，那么property当然就位于该实例中了。此外，要注意instance.constructor现在指向的是SuperType，这是因为原来SubType.prototype中的constructor被重写了的缘故。

注意：

1.子类型有时候需要覆盖超类型中的某个方法，或者需要添加超类型中不存在的某个方法。但不管怎样，给原型添加方法的代码一定要放在替换原型的语句之后。example：

function SuperType(){
	this.property = true;
}

SuperType.prototype.getSuperValue = function(){
	return this.property;
};

function SubType(){
	this.subproperty = false;
}
//继承了 SuperType
SubType.prototype = new SuperType();

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

var instance = new SubType();
alert(instance.getSuperValue());   //false

在以上代码中，标红的部分是两个方法的定义。第一个方法getSubValue（）被添加到了SubType中。第二个方法getSuperValue（）是原型链中已经存在的一个方法，但重写这个方法将会屏蔽原来的那个方法。换句话说，当通过SubType的实例调用getSuperValue（）时，调用的就是这个重定义的方法；但通过SuperType的实例调用getSuperValue（）时，还会继续调用原来的那个方法。这里要额外注意的是，必须在用SuperType的实例替换原型之后，在定义这两个方法。

还有一点需要提醒的是，即在通过原型链实现继承时，不能通过对象字面量创建原型方法。因为这样做就会重写原型链，example：

function SuperType(){
	this.property = true;
}

SuperType.prototype.getSuperValue = function(){
	return this.property;
};

function SubType(){
	this.subproperty = false;
}
//继承了 SuperType
SubType.prototype = new SuperType();

//使用字面量添加新方法，会导致上一行代码无效
SubType.prototype = {
	getSubValue: function(){
		return this.subproperty;
	},

	someOtherMethod :function(){
		return false;
	}
}

var instance = new SubType();
alert(instance.getSuperValue());   //error

以上代码展示了刚刚把SuperType的实例赋值给原型，紧接着又将原型替换成了一个对象字面量而导致的问题。由于现在的原型包含的是一个Object的实例，而非SuperType的实例，因此我们设想中的原型已经被切断——SubType和SuperType之间已经没有关系了。

原型链的问题

原型链虽然很强大，可以用它来实现继承，但它也存在一些问题。其中，最主要的问题来自包含引用类型值的原型。引用类型值的原型属性会被所有实例共享；而这也正是为什么要在构造函数中，而不是在原型对象中定义属性的原型。再通过原型来实现继承时，原型实际上会变成另一个类型的实例。于是，原型的实例属性也就顺理成章地变成了现在的原型属性了。

example：

function SuperType(){
	this.colors = ['red', 'blue', 'green'];
}
function SubType(){
}

//继承了SuperType
SubType.prototype = new SuperType();
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,black'

这个例子中的SuperType构造函数定义了一个colors属性，该属性包含一个数组（引用类型值）。SuperType的每个实例都会有各自包含自己数组的colors属性。当SubType通过原型链继承了SuperType之后，SubType.prototype就变成了SuperType的一个实例，因此它也拥有了一个它自己的colors属性——就跟专门创建了一个SubType.prototype.colors属性一样。但结果是什么呢？结果是SubType的所有实例都会共享一个colors属性。而我们对instance1.colors的修改能够通过instance2.colors反映出来，就已经充分证实了这一点。

原型链的第二个问题是：在创建类似的实例时，不能向超类型的构造函数中传递参数。实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。有鉴于此，再加上前面刚刚讨论过的由于原型中包含引用类型值所带来的问题，实践中很少会单独使用原型链。

借用构造函数

在解决原型中包含引用类型值所带来问题的过程中，开发人员开始使用一种叫做借用构造函数（constructorsealing）的技术（有时候也叫做伪造对象或经典继承）。这种技术的基本思想相当简单，即在子类型构造函数的内部调用超类型构造函数。别忘了，函数只不过是在特定环境中执行代码的对象，因此通过使用apply（）和call（）方法也可以在（将来）新创建的对象上执行构造函数，example：

function SuperType(name){
	this.name = name;
}

function SubType(){
	//继承了SuperType，同时还传递了参数
	SuperType.call(this, 'zhishiqu');

	//实例属性
	this.age = 27;
}
var instance = new SubType();
alert(instance.name); //'zhishiqu'
alert(instance.age); //27

借用构造函数的问题

如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题——方法都在构造函数中定义，因此函数复用就无从谈起了。而且，在超类型的原型中定义方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式。考虑到这些问题，借用构造函数的技术也是很少单独是用的。

组合继承

组合继承（combination inheritance），有时候也叫做伪经典继承，指的是将原型链和借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，即通过在原型上定义方法实现了函数复用，又能够保证每个实例都有它自己的属性。example：

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.sayName = function(){
	alert(this.age);
};

var instance1 = new SubType('zhishiqu', 27);
instance1.colors.push('black');
alert(instance1.colors);  //'red,blue,green,black'
instance1.sayName();  //'zhishiqu'
instance1.sayAge();  //27

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（）也能够用于识别基于组合继承创建的对象。

原型式继承

道格拉斯-克罗克福德在2006年写了一篇文章，题为Prototypal Inheritance in JavaScript （JavaScript中的原型式继承）。在这篇文章中，他介绍了一种实现继承的方法，这种方法并没有使用严格意义上的构造函数。他的想法是借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。为了达到这个目的，他给出了如下函数。

example：

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

在object（）函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回了这个临时类型的一个新实例。从本质上讲，object（）对传人其中的对象执行了一次浅复制。example：

var person = {
	name: 'zhishiqu',
	friends: ['erhui', 'baicai', 'saoqiang']
};

var anotherPerson = object(person);
anotherPerson.name = 'heige';
anotherPerson.friends.push('huanzi');

var yetAnotherPerson = object(person);
yetAnotherPerson.name = 'qier';
yetAnotherPerson.friends.push('laoniu');

alert(person.friends);  //'erhui,baicai,saoqiang,heige,huanzi,laoniu'

克罗克福德主张的这种原型式继承，要求你必须有一个对象可以作为另一个对象的基础。如果有这么一个对象的话，可以把它传递给object（）函数，然后再根据具体需求对得到的对象加以修改即可。在这个例子中，可以作为另一个对象基础的事person对象，于是我们把它传入到object（）函数中，然后该函数就会返回一个新对象。这个新对象将person作为原型，所以它的原型中就包含了一个基本类型值属性和一个引用类型值属性。这意味着person.friends不仅属于person所有，而且也会被anotherPerson以及yetAnotherPerson共享。实际上，这就相当于有创建了person对象的两个副本。

在没有必要兴师动众地创建构造函数，而只想让一个对象与另一个对象保持类似的情况下，原型式继承是完全可以胜任的。不过别忘了，包含引用类型值的属性始终会共享相应的值，就像使用原型模式一样。

寄生式继承

寄生式（parasitic）继承是原型式继承紧密相关的一种思路，并且同样也是有克罗克福德推而广之的。寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。example：

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

在这个例子中，createAnother（）函数接受了一个参数，也就是将要作为新对象基础的对象。然后，把这个对象（original）传递给object（）函数，将返回的结果赋值给clone。再为clone对象添加一个新方法sayHi（），最后返回clone对象。可以向下面这样来使用createAnother（）函数：example:

var person = {
	name: 'zhishiqu',
	friends: ['erhui,erhei,baicai']
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi();  //'hi'

这个例子中的代码基于person返回了一个新对象——anotherPerson。新对象不仅具有person的所有属性和方法，而且还有自己的sayHi（）方法。在主要考虑对象而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式。

寄生组合式继承

组合继承是JavaScript最常用的继承模式；不过，它也有自己的不足。组合继承最大的问题就是无论什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部。

example：

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。于是，这两个属性就屏蔽了原型中的两个同名属性。

所谓寄生组合式继承，即通过借用构造函数来继承属性，通过原型链的混成形式继承方法。其背后的基本思路是：不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后在将结果指定给子类型的原型。寄生组合式继承的基本模式如下所示。

example：

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

这个示例中的inheritPrototype（）函数实现了寄生组合式继承的最简单形式。这个函数接受两个参数：子类型构造函数和超类型构造函数。在函数内部，第一步是创建超类型原型的一个副本。第二步是为创建的副本添加constructor属性，从而弥补因重写原型而失去默认的constructor属性。最后一步，将新创建的对象（即副本）赋值给子类型的原型。这样，我们家就可以调用inheritPrototype（）函数的语句，去替换前面例子中为子类型原型赋值的语句了，example：

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;
}

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

这个例子的高效体现在它只调用了一次Supertype构造函数，并且因此避免了在SubType.prototype上面创建不必要的、多余的属性。与此同时，原型链还能保持不变；因此，还能够正常使用instanceof和isPrototypeof（）。开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。