寄生式继承

基本思路

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

function createAnother(original){
    var clone = Object(original);     //通过调用函数创建一个新对象
    clone.sayHi = function(){
        alert("hi");
    }
    return clone;
}

var person = {
    name:"Wonder",
    colors:["blue","green"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi();  //"hi"

寄生式继承不能做到函数复用，所以效率降低。

寄生组合式继承

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

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

基本思路

通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。
使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

function inheritPrototype(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;
}

inheritPrototype(SubType,superType);

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

优点：高效率——只调用了一次SuperType构造函数，并且因此避免了在SubType.prototype上面创建不必要的、多余的属性。另外，原型链还能保持不变。

寄生组合式继承是引用类型最理想的继承范式。