摘要：創(chuàng)建實(shí)例時(shí)無法向的構(gòu)造函數(shù)傳遞參數(shù)在不影響所有對象實(shí)例的情況下易錯(cuò)點(diǎn)添加原型方法的代碼要放在替換原型的語句之后。繼承屬性繼承方法原型式繼承原型式繼承并沒有使用嚴(yán)格意義上的構(gòu)造函數(shù)。

許多OO 語言都支持兩種繼承方式：

接口繼承:只繼承方法簽名

實(shí)現(xiàn)繼承:繼承實(shí)際的方法。

由于函數(shù)沒有簽名，在ECMAScript 中無法實(shí)現(xiàn)接口繼承。ECMAScript 只支持實(shí)現(xiàn)繼承

原型鏈?zhǔn)荍avascript實(shí)現(xiàn)繼承的主要方法

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();
console.log(instance.getSuperValue())//true

//instanceof用于測試實(shí)例與原型鏈中出現(xiàn)過的構(gòu)造函數(shù)的關(guān)系
console.log(instance instanceof object) //true
console.log(instance instanceof SuperType) //true
console.log(instance instanceof SubType) //true

console.log(Object.prototype.isPrototypeof(instance)) //true
console.log(SuperType.prototype.isPrototypeof(instance)) //true
console.log(SubType.prototype.isPrototypeof(instance)) //true

實(shí)踐中較少多帶帶使用原型鏈繼承

注意：

instance.constructure現(xiàn)在指向的是SuperType

instance.toString現(xiàn)在指向的是Object.prototype

SuperType中的引用值類型會(huì)在所有SubType中共享。

創(chuàng)建SubType實(shí)例時(shí),無法向SuperType的構(gòu)造函數(shù)傳遞參數(shù)（在不影響所有對象實(shí)例的情況下）

易錯(cuò)點(diǎn)

SubType、SuperType添加原型方法的代碼要放在替換原型的語句之后。否則SubType添加的原型方法會(huì)失效，因?yàn)樵蛯ο蟊惶鎿Q了。

不能通過字面量創(chuàng)建SubType的原型對象。因直接對原型賦值字面量對象會(huì)替換SubType的原型，打破了原型鏈。

解決了Javascript原型鏈繼承中引用值類型被共享的問題

function SuperType(){
    this.colors=["red","blue","green"];
}
function SubType(){
    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(this)或apply(this)我們再SubType的實(shí)例環(huán)境下調(diào)用了SuperType的構(gòu)造函數(shù)，因此在SubType對象上執(zhí)行了SuperType的對象初始化代碼，因此每個(gè)SubType都具有了自己的colors屬性

優(yōu)勢

可以傳遞在子類構(gòu)造函數(shù)中向超類構(gòu)造函數(shù)傳遞參數(shù)

問題

因?yàn)榉椒ǘ荚跇?gòu)造函數(shù)中定義的，因此無法實(shí)現(xiàn)函數(shù)復(fù)用，每個(gè)對象都重新定義了一次方法。

無論什么情況下，都會(huì)調(diào)用兩次超類型構(gòu)造函數(shù)：一次是在創(chuàng)建子類型原型的時(shí)候，另一次是在子類型構(gòu)造函數(shù)內(nèi)部。

注意

為了確保SuperType構(gòu)造函數(shù)不會(huì)重寫子類屬性，應(yīng)在調(diào)用SuperType的構(gòu)造函數(shù)之后再添加子類自身的屬性。

將原型鏈和借用構(gòu)造函數(shù)組合到一塊，發(fā)揮二者之長的一種繼承模式。

原型鏈實(shí)現(xiàn)對屬性和方法的復(fù)用。

借用構(gòu)造函數(shù)實(shí)現(xiàn)對實(shí)例屬性的繼承。

function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
    console.log(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(){
    console.log(this.age);
};
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
console.log(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //"Nicholas";

instance1.sayAge(); //29
var instance2 = new SubType("Greg", 27);
console.log(instance2.colors); //"red,blue,green"
instance2.sayName(); //"Greg";
instance2.sayAge(); //27

原型式繼承并沒有使用嚴(yán)格意義上的構(gòu)造函數(shù)。是借助原型可以基于已有的對象創(chuàng)建新對象，同時(shí)還不必因此創(chuàng)建自定義類型。

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

在object()函數(shù)內(nèi)部，先創(chuàng)建了一個(gè)臨時(shí)性的構(gòu)造函數(shù)，然后將傳入的對象作為這個(gè)構(gòu)造函數(shù)的原型，最后返回了這個(gè)臨時(shí)類型的一個(gè)新實(shí)例。從本質(zhì)上講，object()對傳入其中的對象執(zhí)行了一次淺復(fù)制。
ECMAScript 5 通過新增Object.create()方法規(guī)范化了原型式繼承。這個(gè)方法接收兩個(gè)參數(shù)：

一個(gè)用作新對象原型的對象和（可選的）

一個(gè)為新對象定義額外屬性的對象。

在傳入一個(gè)參數(shù)的情況下，Object.create()與object()方法的行為相同。
Object.create()方法的第二個(gè)參數(shù)與Object.defineProperties()方法的第二個(gè)參數(shù)格式相同:每個(gè)屬性都是通過自己的描述符定義的。以這種方式指定的任何屬性都會(huì)覆蓋原型對象上的同名屬性。
在沒有必要興師動(dòng)眾地創(chuàng)建構(gòu)造函數(shù)，而只想讓一個(gè)對象與另一個(gè)對象保持類似的情況下，原型式繼承是完全可以勝任的。

創(chuàng)建一個(gè)僅用于封裝繼承過程的函數(shù)，該函數(shù)在內(nèi)部以某種方式來增強(qiáng)對象，最后再像真地是它做了所有工作一樣返回對象

function createAnother(original){
    //通過調(diào)用函數(shù)創(chuàng)建一個(gè)新對象，任何能夠返回新對象的函數(shù)都適用該模式
    var clone = object(original); 
        clone.sayHi = function(){ //以某種方式來增強(qiáng)這個(gè)對象
        alert("hi");
    };
    return clone; //返回這個(gè)對象
}
var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi(); //"hi"

問題

無法做到函數(shù)復(fù)用而降低效率

由于組合繼承兩次調(diào)用了SuperType的構(gòu)造函數(shù)，SubType就具有了兩組SuperType的屬性：一組在實(shí)例上，一組在SubType 原型中。
寄生組合式繼承通過借用構(gòu)造函數(shù)來繼承屬性，通過原型鏈的混成形式來繼承方法。
基本思路：不必為了指定子類型的原型而調(diào)用超類型的構(gòu)造函數(shù)，我們所需要的無非就是超類型原型的一個(gè)副本而已。
本質(zhì)：使用寄生式繼承來繼承超類型的原型，然后再將結(jié)果指定給子類型的原型。

function inheritPrototype(subType, superType){
    var prototype = object(superType.prototype); //創(chuàng)建對象
    prototype.constructor = subType; //增強(qiáng)對象
    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);
};

優(yōu)勢

高效率：只調(diào)用了一次SuperType 構(gòu)造函數(shù)，并且因此避免了在SubType.prototype 上面創(chuàng)建不必要的、多余的屬性。

原型鏈還能保持不變；因此，還能夠正常使用instanceof 和isPrototypeOf()

寄生組合式繼承是引用類型最理想的繼承范式。

YUI 的YAHOO.lang.extend()方法采用了寄生組合繼承，從而讓這種模式首次出現(xiàn)在了一個(gè)應(yīng)用非常廣泛的JavaScript 庫中。

寄生組合式繼承與寄生組合式繼承中inheritPrototype功能一致，因此如果不希望在子類間共享引用類型值屬性，還需組合借用構(gòu)造函數(shù)繼承。

exports.inherits = function(ctor,superCtor){
    ctor.super_ = superCtor;
    ctor.prototype = Object.create(superCtor.prototype,{
        constructor:{
            value:ctor,
            enumerable:false,
            writable:true,
            configurable:true
        }
    };
};