摘要：通過方法或方法也可以，實質(zhì)上是在未來將要新創(chuàng)建的實例的環(huán)境下調(diào)用構(gòu)造函數(shù)。組合繼承指的是將原型鏈繼承和借用構(gòu)造函數(shù)繼承的技術(shù)組合到一塊，從而發(fā)揮二者之長的一種繼承模式。該模式通過借用構(gòu)造函數(shù)繼承屬性，通過重新子類型繼承方法。

       function SuperType() {
           this.property = true;
       }
        //  在原型鏈上定義方法。
       SuperType.prototype.getSuperValue = function (){
           return this.property;
       }

       function SubType() {
           this.subproperty = false;
       }

        //  替換SubType原型，達到繼承效果。
       SubType.prototype = new SuperType();

        //  開始寫SubType的方法，注：SubType的方法必須寫在替換SubType原型語句后
       SubType.prototype.getSubValue = function (){
           return this.subproperty;
       }

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

原型鏈繼承的原理如期名，是利用創(chuàng)建父類（SuperType）的實例，并將該實例賦值給子類（SubType）.prototype實現(xiàn)的，實質(zhì)是重寫子類的原型對象。

原型鏈繼承特點：

引用類型值的原型屬性會被所有實例共享。

在創(chuàng)建子類型的實例時，沒辦法再不影響所有對象實例的情況下向超類傳遞參數(shù)。

即實現(xiàn)所有屬性方法共享，但無法做到屬性、方法獨享。

        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      

借用構(gòu)造函數(shù)繼承（constructor stealing），該繼承思想很簡單，即在子類型構(gòu)造函數(shù)的內(nèi)部調(diào)用超類型構(gòu)造函數(shù)即可。通過call()方法（或apply()方法也可以），實質(zhì)上是在（未來將要）新創(chuàng)建的SubType實例的環(huán)境下調(diào)用SuperType構(gòu)造函數(shù)。

借用構(gòu)造函數(shù)繼承特點：

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

方法都在構(gòu)造函數(shù)中定義，無法實現(xiàn)函數(shù)復(fù)用。

超類型的原型中定義的方法對子類不可見。

即實現(xiàn)所有屬性獨享，但無法做到方法繼承。

        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);  //第二次調(diào)用SuperType
            this.age = age;
        }

        //繼承方法
        SubType.prototype = new SuperType();  //第一次調(diào)用SuperType
        SubType.prototype.constructor = SubType;
        SubType.prototype.sayAge = function(){
            alert(this.age);
        }

        var instance1 = new SubType("Y",21);
        instance1.colors.push("black");
        alert(instance1.colors);  //red,blue,green,black
        instance1.sayName();  //Y
        instance1.sayAge();  //21

        var instance2 = new SubType("Z",22);
        alert(instance2.colors);  //red,blue,green
        instance2.sayName();  //Z
        instance2.sayAge();  //22

組合繼承（combination inheritance）又叫偽經(jīng)典繼承，是JavaScript中最常用的繼承模式。組合繼承指的是將原型鏈繼承和借用構(gòu)造函數(shù)繼承的技術(shù)組合到一塊，從而發(fā)揮二者之長的一種繼承模式。該模式通過借用構(gòu)造函數(shù)繼承屬性，通過重新子類型prototype繼承方法。

組合繼承特點：

實現(xiàn)了所有方法共享，屬性獨享。

instanceof()和isprototypeOf()能夠識別基于組合繼承創(chuàng)建的對象。

實現(xiàn)的時候調(diào)用了兩次超類（父類），產(chǎn)生多余屬性。

        //  工具函數(shù)，實質(zhì)是對傳入的對象執(zhí)行一次淺拷貝。
        function object(o) {
            function F() {}
            F.prototype = o;
            return new F();
        }

        var person = {
            name:"Y",
            friends:["S","C","V"],
            say:function () {
                alert(this.friends);
            }
        };

        var anotherPerson = object(person);
        anotherPerson.name = "G";
        anotherPerson.friends.push("R");

        var yetAnotherPerson = object(person);
        yetAnotherPerson.name = "L";
        yetAnotherPerson.friends.push("B");

        person.friends.push("my");

        anotherPerson.say();  //S,C,V,R,B,my
        alert(person.friends);  //S,C,V,R,B,my
        
        

原型式繼承是由道格拉斯·克羅克福德提出的，該模式要求你必須有一個對象可以作為另外一個對象的基礎(chǔ)。該模式將一個對象傳遞給object()函數(shù)，然后再根據(jù)具體需求對得到的對象加以修改即可。

原型式繼承特點：

以傳入object的對象為原型，拷貝一個副本并反回。

做不到函數(shù)復(fù)用，導(dǎo)致效率低。

對象的引用類型所有實例共享（person的引用類型friends不僅屬于person所有，而且也會被antherPerson和yetAnotherPerson共享）。

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

        function createAnother(original) {
            var clone = object(original);
            clone.sayHi = function (){
                alert(this.friends);
            };
            return clone;
        }
        var person = {
            name:"Y",
            friends:["S","C","V"]
        };

        var anotherPerson = createAnother(person);
        anotherPerson.friends.push("test");
        anotherPerson.sayHi();

        var anotherPerson2 = createAnother(person);
        anotherPerson2.sayHi();

寄生式繼承（parasitic）同樣是由克羅克福德提出并推廣而之的。該模式創(chuàng)建一個僅用于封裝繼承過程的函數(shù)，該函數(shù)的內(nèi)部以某種方式增強對象，最后再像真地式它做了所有工作一樣返回對象。

寄生式繼承特點：

做不到函數(shù)復(fù)用，導(dǎo)致效率低。

對象的引用類型所有實例共享。

        function object(o) {
            function F() {}
            F.prototype = o;
            return new F();
        }
        
        //  將超類型的prototype淺拷貝一遍并賦值給子類型的prototype
        //  （相當于利用超類型prototype重寫子類型prototype以達到繼承效果）
        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);
        }

        var instance1 = new SubType("Y",21);
        instance1.colors.push("black");
        alert(instance1.colors);  //red,blue,green,black
        instance1.sayName();  //Y
        instance1.sayAge();  //21

        var instance2 = new SubType("Z",22);
        alert(instance2.colors);  //red,blue,green
        instance2.sayName();  //Z
        instance2.sayAge();  //22

原理如圖：

寄生組合式繼承解決了組合繼承最大的問題——無論什么情況下，都會調(diào)用兩次超類型構(gòu)造函數(shù)。該模式思路是：不必為了指定子類型的原型而調(diào)用超類型的構(gòu)造函數(shù)，我們所需的無非就是超類型原型的副本而已。本質(zhì)上，就是使用寄生式繼承來繼承超類型的原型，然后再將結(jié)果指定給子類型的原型。

寄生組合式繼承特點：

實現(xiàn)了所有方法共享，屬性獨享。

instanceof()和isprototypeOf()能夠識別基于組合繼承創(chuàng)建的對象。

參考自《JavaScript高級程序設(shè)計》