原型链
JavaScript的继承主要依靠原型链来实现的。我们知道，构造函数，原型，和实例之间的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个原型对象的指针。
实现原型链的方式如下
function SuperType(){
this.property=true;
}
SuperType.prototype.getSuperValue=function(){
return this.property;
};
function SubType(){
this.subpropertype=false;
}
//让原型对象称为另一个构造函数的实例
SubType.prototype=new SuperType();
SubType.prototype.getSubValue=function(){
return this.subpropertype;
};
var instance=new SubType();
alert(instance.getSuperValue());//true
//这个实例继承了SuperType.prototype的constructor属性？
alert(instance.constructor==SuperType);//true
上述代码继承是通过SubType.prototype=new SuperType();来实现，创建SuperType的实例，并将该实例赋给SubType.prototype。
继承实现的本质是重写原型对象，代之以一个新类型的实例。
下图为构造函数，实例以及原型之间的关系图：
原型链顶端:所有引用类型都默认继承Object，所以，所有函数的默认原型都是Object的实例，默认原型都会包含一个内部指针[[prototype]]，指向Object.prototype。
原型链缺点
- 实例属性变为原型属性
function SuperType(){
this.color=["red","green","blue"];
}
function SubType(){
}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"
var instance2 = new SubType();
alert(instance2.color);//"red,green,blue,black"
这个问题似曾相识，正是原型模式创建对象时由于共享引用类型属性，导致牵一发动全身的问题。
- 在创建子类型时，不能向超类型的构造函数传递参数。
所以，单独使用原型链情况较少。
借用构造函数
针对原型链的第一个问题，我们可采用借用构造函数的技术来解决。基本思想就是在子类型构造函数的内部调用超类型构造函数。看例子：
function SuperType(){
this.color=["red","green","blue"];
}
function SubType(){
//继承自SuperType
SuperType.call(this);
}
var instance1 = new SubType();
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"
var instance2 = new SubType();
alert(instance2.color);//"red,green,blue"
在新创建的SubType子类型的实例中调用SuperType超类型构造函数，就可以在新的实例对象上执行SuperType()函数中定义的所有对象初始化代码。问题不就解决了吗！
但是，这种模式的缺点是在超类型中定义的方法，对子类型是不可见的，无法实现共享方法。
所以，这种方法也不常用。
组合继承
组合上述两种方法就是组合继承。用原型链实现对原型属性和方法的继承，用借用构造函数技术来实现实例属性的继承。无疑，集两者之大成，这才是最常用的继承模式。看：
function SuperType(){
this.name=name;
this.color=["red","green","blue"];
}
SuperType.prototype.sayName = function(){
alert(this.name);
}
function SubType(name,age){
//继承了SuperType
SuperType.call(this,name);
//自己又添加了一个
this.age = age;
}
//构建原型链
SubType.prototype = new SuperType();
//重写SubType.prototype的constructor属性，指向自己的构造函数SubType
SubType.prototype.constructor=SubType;
//原型方法，被实例们共享
SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType("Nichola",29);
instance1.color.push("black");
alert(instance1.color);//"red,green,blue,black"
instance1.sayName();//"Nichola"
instance1.sayAge();//29
var instance2 = new SubType("Grey",24);
alert(instance2.color);//"red,green,blue"
instance2.sayAge();//24
instance2.sayName();//"Grey"
这个方案已经看似perfect了。但是，后面再说。
原型式继承
借助原型可以基于已有的对象创建新的对象，不必因此创建自定义类型。
function object(o){ //返回一个对象以传入对象为原型
function F(){}
F.prototype = o;
return new F();
}
var person ={
name:"Nichola",
friends:["Shelly","Court","Van"]
};
var person1 = object(person);
person1.name = "Grey";
person1.friends.push("Rob");
var person2 = object(person);
person2.name = "Linda";
person2.friends.push("Barble");
alert(person.friends);//"Shelly,Court,Van,Grey,Barble"
使用场合：需求简单，只需要让新对象与已有对象保持相似。优点，不必创建构造函数，缺点，包含引用类型值的属性始终共享相应的值。
Object.create()正是为实现这种模式诞生。
寄生式继承
与原型式继承相似，也是基于某个对象或某些信息创建对象，然后增强对象，最后返回对象。实现方法：创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后返回这个对象。看！
function createAnother(original){
var clone = object(original);//通过调用函数创建对象
clone.sayHi= function (){ //增强对象
alert("Hi");
};
return clone;//返回对象
}
//可以返回新对象的函数
function object(o){
function F(){}
F.prototype = o;
return new F();
}
var person ={
name:"Nichola",
friends:["Shelly","Court","Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi();//"Hi"
这种继承模式适用的场合：任何返回新对象的函数都可以。缺点是不能做到函数复用。
寄生组合式继承
上面说到组合继承也有缺点，就是无论在何种情况下，都会调用两次超类型构造函数，一次是在创建子类型原型时，还有一次是在子类型构造函数内部。
这种模式集中了寄生式和组合式继承的优点。
function SuperType(){
this.name=name;
this.color=["red","green","blue"];
}
function SubType(){
//第二次调用SuperType()
SuperType.call(this,name);
this.age = age;
}
//第一次调用SuperType()
SubType.prototype = new SuperType();
SubType.prototype.constructor=SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType("Nichola",29);
第一次调用SuperType():给SubType.prototype写入两个属性name，color
第二次调用SuperType()：给instance1写入两个属性name，color
实例对象instance1上的两个属性就屏蔽了其原型对象SubType.prototype的两个同名属性。所以，组合模式的缺点就是在SubType.prototype上创建不必要的重复的属性。
寄生组合式继承基本模式：
function inheritPrototype(SubType,SuperType){
var prototype = object(superType.prototype);//创建对象
prototype.constructor = SubType;//增强对象
SubType.prototype = prototype;//制定对象
}
首先，创建超类型的一个副本；
其次，为副本添加constructor属性，使其指向子类型构造函数；
最后，将副本赋值给子类型原型。
function SuperType(){
this.name=name;
this.color=["red","green","blue"];
}
function SubType(){
SuperType.call(this.name);
this.age = age;
}
function inheritPrototype(SubType,SuperType){
var prototype = object(superType.prototype);//创建对象
prototype.constructor = SubType;//增强对象
SubType.prototype = prototype;//制定对象
}
SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType("Nichola",29);
借用构造函数来继承实例属性，使用寄生式继承来继承超类型的原型，然后再将结果赋给子类型原型。这样既可以继承超类型的实例属性，也可继承超类型原型中的原型属性。这是最优解。
