对于面向对象语言的继承有两种，一种是接口集成，一种是实现继承，ECMAScript没有接口，所以只能实现继承，而实现继承主要是靠原型链来实现的。

1.原型链

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

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

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

function SuperType() {
    this.property = true;
}
SuperType.prototype.getSuperValue = function() {
    return this.property;
}
function subType() {
    this.property = false;
}
//继承了SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function (){
    return this.property;
}
var instance = new SubType();
alert(instance.getSuperValue());//true

确定原型和实例的关系可以通过instanceof和isPrototypeOf()，只要用instanceof这个操作符来测试实例与原型中出现过的构造函数，结果就会返回true。用isPrototypeOf()方法也会返回true。

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

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

由于是原型链的关系，我们可以说instance是Object、SuperType、SubType中任何一个类型的实例。

子类型重写超类型的方法时，给原型添加方法的代码一定要放在替换原型的语句之后。

  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 SuperType(){
            this.property = true;
    };

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

第二个方法是原型链存在的方法，重写这个方法，SubType调用getSuperValue()方法时，调用的就是重新定义的方法，但是SuperType的实例调用getSuperValue()时，还会用原来那个方法。

var instance1 = new SuperType();
alert(instance1.getSuperValue());  //true

原型链的问题：

引用类型值的原型属性会被所有实例共享；
在创建子类时，不能向超类型的构造函数中传递参数。

所以实践中很少单独使用原型链。

2 借用构造函数

基本思想：在子类型构造函数的内部调用超类构造函数，通过使用call()和apply()方法可以在新创建的对象上执行构造函数。

function SuperType() {
    this.colors = ["red","blue","green"];
}
function SubType() {
    SuperType.call(this);//继承了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"

对于原型链而言，借用构造函数有一个很大优势，就是在子类构造函数中向超类型构造函数传递参数。例子如下：

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

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

  var instance = new SubType();
  alert(instance.name);    //"Nicholas";
  alert(instance.age);     //29

借用构造函数的问题：

方法都在构造函数中定义，函数复用就无从谈起；
在超类原型中定义的方法，子类不可见。

所以构造函数技术也很少用。

3.组合继承

基本思想：将原型链和借用构造函数的技术组合在一块，从而发挥两者之长的一种继承模式。使用原型链实现对原型属性和方法的继承，通过构造函数实现对实例属性的继承。这样通过原型方法实现函数复用，又能保证每个实例都有自己的属性。

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("Amy",18);
instance1.colors.push("black");
alert(instance1.colors);//"red","blue","green","black"
instance1.sayName();//"Amy"
instance1.sayAge();//18
var instance2 = new SubType("Joy",20);
alert(instance2.colors);//"red","blue","green"
instance2.sayName();//"Joy"
instance2.sayAge();//20

组合继承是JavaScript中最常用的继承模式。

缺点：无论什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部，子类型最终会包含超类型对象的全部实例属性，但是我们不得不在调用子类型构造函数时重写这些属性。

4.原型式继承

基本想法：借助原型可以基于已有的对象创建新对象，同时还不必须因此创建自定义的类型。为达到这个目的，道格拉斯克罗克福德给出如下函数：

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

在object()函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回这个临时类型的一个新实例。如下例子：

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

这种模式要求必须有一个对象可以作为另一个对象的基础。如果有这么一个对象的话，可以把它传递给object()函数，然后再根据对象的需求对得到的对象加以修改。

缺点：包含引用类型值的属性始终都会共享，就像使用原型模式一样。

5.寄生式继承

寄生式继承是与原型式继承紧密相关的一种思路，与寄生构造函数和工厂模式类似。

基本思想：创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真正是它做了所有工作一样返回对象。

function createAnother(original) {
    var clone = object(original);      //通过调用函数创建一个对象
    clone.sayHi = function () {        //以某种方式来增强这个对象
        alert("hi");
    };
    return clone;                      //返回这个对象
}
var person = {
    name:"Amy",
    friends:["Shelby","Court","Van"];
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi();               //"hi"

缺点：使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率；这点与构造函数模式类似。

6.寄生组合式继承

基本思想：通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。也就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。
其基本模型如下所示：

function inheritProperty(subType, superType) {
    var prototype = object(superType.prototype);//创建对象
    prototype.constructor = subType;//增强对象
    subType.prototype = 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;
}
inheritProperty(SubType,SuperType);
SubType.prototype.sayAge = function() {
    alert(this.age);
}

此例子只调用了一次SuperType构造函数，并因此避免了在SuperType.prototype上面创建不必要的、多余的属性。与此同时，原型链还能保持不变，此方法是引用类型最理想的继承方式。

【JavaScript】（五）6种继承方式