摘要：前言雖然使用構造函數或者使用對象字面量可以很方便的用來創建一個對象，但這種方式有一個明顯的缺點使用一個接口創建多個對象會產生很多冗余的代碼。即調用構造函數所創建的那個對象的原型對象好處是可以讓所有對象的實例共享他的屬性的方法。

雖然使用Object構造函數或者使用對象字面量可以很方便的用來創建一個對象，但這種方式有一個明顯的缺點：使用一個接口創建多個對象會產生很多冗余的代碼。因此為了解決這個問題，人們開始使用以下幾種方式來常見對象。

該模式抽象了創建對象的具體過程，用函數來以特定接口創建對象的細節

    function cPerson(name,sex,age){
    var o = new Object();
    o.name = name;
    o.sex = sex;
    o.age = age;
    o.show = function(){
        console.log(this.name,this.age,this.sex);
    }
    return o;
}
    var p1 = cPerson("謙龍","男","100");
        p1.show();
    var p2 = cPerson("雛田","女","14");
        p2.show();

工廠模式測試

工廠方式的問題：使用工廠模式能夠創建一個包含所有信息的對象，可以無數次的調用的這個函數。雖然其解決了創建多個相似對象的問題，但卻沒有解決對象識別的問題(即如何得知一個對象的類型)

function CPerson(name,sex,age) {//注意這里 構造函數首字母大寫
    this.name = name;
    this.sex = sex;
    this.age = age;
    this.show = function () {
        console.log(this.name, this.age, this.sex);
    }
}


var p1 = new CPerson("謙龍","男","100");
    p1.show();
var p2 = new CPerson("雛田","女","14");
    p2.show();

構造函數模式測試

注意構造函數與工廠模式有些不同的地方，如下

構造函數首字母大寫

沒有顯式地創建對象

將屬性和方法賦值給了 this對象

沒有return語句

而且以這種方式來調用構造函數會大致經歷一下幾個步驟

創建一個新的對象

將構造函數的作用域賦值給這個對象（因此this就指向了這個對象）

執行構造函數中的代碼（即給新對象添加屬性和方法的過程）

返回對象

注意：構造函數其實和普通的函數沒有太大的差別，唯一的不同在于調用方式的不同。以下演示不同的幾種調用方式

    // 調用方式1 new 方式
    
    var p1 = new CPerson("謙龍","男","100");
    p1.show();//謙龍 100 男
    
    // 調用方式2 普通函數調用
    
    CPerson("謙龍","男","100");
    window.show()//謙龍 100 男 注意屬性和方法會被設置到window對象上
    
    // 調用方式3 在另一個對象的作用域中調用
    var obj = new Object();
        CPerson.call(obj,"謙龍","男","100");
        obj.show(); //謙龍 100 男 在obj的作用域

構造函數的問題：使用構造函數最主要的問題就是每個方法都要在每個實例上重新創建一次，p1與p2的都有show方法，但不是同一個Function的實例，因為function在js中也是一個對象。因此他們共有的show方法并不相等。

每個函數都有一個prototype屬性，這個屬性是一個指針，指向一個對象。而這個對象的用途是 包含可以由特定類型的所有實例 共享的屬性和方法。即調用構造函數所創建的那個對象的 原型對象
好處是可以讓所有對象的實例共享他的屬性的方法。即無需在構造函數中定義實例的信息

 function CPerson(){

    }
    CPerson.prototype.name="謙龍";
    CPerson.prototype.sex="男";
    CPerson.prototype.age=100;
    CPerson.prototype.show=function(){
        console.log(this.name, this.age, this.sex);
    }
    var p1 = new CPerson();
        p1.show(); //謙龍 100 男
    var p2 = new CPerson();
        p2.show();//謙龍 100 男
        console.log(p1.show == p2.show)//true

原型模式測試

由上圖可知p1與p2共享屬性和方法

原型模式的問題：

省略了為構造函數傳遞初始化參數，導致默認情況下所有實例將得到相同的屬性值

所有屬性都會被實例所共享，當屬性的類型是引用類型的時候會出一定的問題，實例間對該屬性的修改會相互影響
針對以上所說的第二個問題我們給出實例

        function CPerson(){

        }

        CPerson.prototype.name="謙龍";
        CPerson.prototype.sex="男";
        CPerson.prototype.age=100;
        CPerson.prototype.job=["前端","后端"];
        CPerson.prototype.show=function(){
            console.log(this.name, this.age, this.sex);
        }
        var p1 = new CPerson();
            p1.job.push("測試");
            console.log(p1.job);//["前端", "后端", "測試"]
        var p2 = new CPerson();
            console.log(p2.job);//["前端", "后端", "測試"]
            console.log(p1.job == p2.job);// true

測試

由以上可以看出，兩個對象p1，p2對job的修改會相互影響，但按照正常思維，實例一般要有自己的全部的屬性。

該方式利用構造函數定義實例屬性、利用原型定義方法和共享的屬性，結果每個實例都有一份實例屬性的副本，而且共享著方法的引用，可謂是集兩家之所長。

 function CPerson(name,sex,age) {//注意這里 構造函數首字母大寫
         this.name = name;
         this.sex = sex;
         this.age = age;
         this.job=["前端","后端"];
     }

    CPerson.prototype={
        constructor:CPerson,//注意這里
        show : function () {
            console.log(this.name, this.age, this.sex);
        }
    }

    var p1 = new CPerson("謙龍","男",100);
    var p2 = new CPerson("雛田","女",20);
        p1.job.push("測試");
        console.log(p1.job);//["前端", "后端", "測試"]
        console.log(p2.job);//["前端", "后端"]
        console.log(p1.job == p2.job);//fasle
        console.log(p1.show == p2.show);//true

組合模式測試

說明：這種組合模式是使用最廣泛、認同度最高的一種創建自定義類型的方法。

動態原型模式將所有的信息都封裝在了函數中，而通過構造函數中初始化原型，保持了同時使用構造函數和原型的優點

        function CPerson(name,sex,age) {//注意這里 構造函數首字母大寫
            this.name = name;
            this.sex = sex;
            this.age = age;
            this.job=["前端","后端"];
            if(typeof this.show !="function"){ //注意這里 
                console.log("just one");
                CPerson.prototype.show=function(){
                    console.log(this.name, this.age, this.sex);
                }
            }
        }


        var p1 = new CPerson("謙龍","男",100); //just one
        var p2 = new CPerson("雛田","女",20);//沒有輸出

動態原型模式測試

該方式的基本思想是創建一個函數，用來封裝創建對象的代碼，然后再返回新創建的對象。構造函數在不返回值的情況下，默認會返回新對象的實例，而通過return語句可以修改調用構造函數時的返回值。

該方式有一定的應用場景比如，當我們想創建一個具有額外方法的數組而又不能修改Array構造函數的情況下，可以使用這種模式

 function MyOwnArray(){
        var arr=new Array();//創建新對象
            arr.push.apply(arr,arguments);
            arr.show=function(){
                console.log(this.join("|"));
            }
        return arr;
    }

    var arr1 = new MyOwnArray("謙龍","男",100);
        arr1.show();

寄生構造函數模式測試

穩妥對象即沒有公共屬性，方法也不引用this對象，穩妥對象最適合在一些安全的環境中（例如禁止使用this和new）或者防止數據被其他應用程序修改的時候使用。

注意：穩妥構造函數和寄生式構造函數有許多類似的地方，以下是他們的不同之處

不使用new操作符來調用構造函數

創建對象的實例方法不使用this對象

  function CPerson(name,sex,age){
        var obj = new Object();
            // private members
        var myOwnName="謙龍";
        obj.showOwnName=function(){
            console.log(myOwnName);//只有通過該方法才能訪問myOwnName 私有屬性
        }
        obj.show=function(){
            console.log(name,sex,age);
        }
        return obj;
    }

    var p1=CPerson("謙龍","男","100");
        p1.show();
        p1.showOwnName();

穩妥構造函數模式測試

除了通過調用對應的方法來訪問其數據成員，沒有別的方法可以訪問到原始添加的數據，其提供的這種安全機制適合在例如ADsafe等的環境下使用