摘要：就是通過調(diào)用構(gòu)造函數(shù)而創(chuàng)建的那個對象實例的原型對象。與寄生構(gòu)造函數(shù)模式類似，使用穩(wěn)妥構(gòu)造函數(shù)模式創(chuàng)建的對象與構(gòu)造函數(shù)之間也沒有什么關(guān)系，因此操作符對這種對象也沒有什么意義

雖然Object構(gòu)造函數(shù)或?qū)ο笞置媪慷伎梢杂脕韯?chuàng)建單個對象，但是這些方法有明顯的缺點：使用同一個接口創(chuàng)建很多對象，會產(chǎn)生大量重復代碼。因此人們開始使用工廠模式。

這種模式抽象了創(chuàng)建具體對象的過程

function createPerson(name,age){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.sayName = function(){
        alert(this.name);
    };
    return o;
}

var person1 = new createPerson("liaojin",18);
var person2 = new createPerson("xiaoguan",20);

函數(shù)createPerson()能夠根據(jù)接受的參數(shù)來構(gòu)建一個包含所有必要信息的Person對象。可以無數(shù)次的調(diào)用這個函數(shù)，而每次它都會返回一個包含兩個屬性以個方法的對象。工廠模式雖然解決了創(chuàng)建多個相似對象的問題，但卻沒有解決對象識別的問題（即怎樣知道一個對象的類型）。

使用構(gòu)造函數(shù)將上述例子重寫

function Person(name,age){
    this.name = name;
    this.age = age;
    this.sayName = function(){
        alert(this.name);
    };
}

var person1 = new Person("liaojin",18);
var person2 = new Person("xiaoguan",20);

在這個例子中，Person()函數(shù)取代了createPerson()函數(shù)。注意到Person()中的代碼與createPerson()的不同之處：
1.沒有顯示的創(chuàng)建對象
2.直接將屬性和方法賦值給了this對象
3.沒有return語句
要創(chuàng)建Person新實例，必須使用new操作符。這種方式會經(jīng)理以下四個步驟：
1.創(chuàng)建一個新對象
2.將構(gòu)造函數(shù)的作用域賦給新對象（因此this就指向了這個新對象）
3.執(zhí)行構(gòu)造函數(shù)中的代碼（為這個新對象添加屬性）
4.返回新對象
person1和person2分別保存著Person的一個不同實例。這兩個對象都有一個constructor屬性，該屬性指向Person。

alert(person1.constructor == Person);//true
alert(person2.constructor == Person);//true

對象的constructor屬性最初是用來表示對象類型的，但是檢測對象類型還是instanceof更可靠一些。這個例子中創(chuàng)建的所有對象即是Object的實例，同時也是Person的實例。
創(chuàng)建自定義的構(gòu)造函數(shù)意味著將來可以將它的實例標識為一種特定的類型；person1和person2之所以同時是Object的實例，是因為所有對象均繼承自O(shè)bject.

將構(gòu)造函數(shù)當做函數(shù)

構(gòu)造函數(shù)與其他函數(shù)唯一的區(qū)別就在于調(diào)用他們的方式不同。
任何函數(shù)只要通過new操作符來調(diào)用，那他就可以作為構(gòu)造函數(shù)；而任何函數(shù)如果不通過new操作符來調(diào)用，那他跟普通函數(shù)沒有區(qū)別。
如上述例子中的Person()函數(shù)可以通過下列任何一種方式來調(diào)用。

//當做構(gòu)造函數(shù)調(diào)用
var person = new Person("liaojin",18);
person.sayName();//liaojin

//作為普通函數(shù)調(diào)用
Person("lihua",12);
window.sayName();//lihua

//在另一個對象的作用域調(diào)用
var o = new Object();
Person.call(o,"xiaoguan",20);
o.sayName();//xiaoguan

構(gòu)造函數(shù)的問題

構(gòu)造函數(shù)模式雖然好用，但是也有缺點。使用構(gòu)造函數(shù)的主要問題，就是每個方法都要在每個實例上重新創(chuàng)建一遍。如同this.sayName =new function(){alert(this.name);};在上面的構(gòu)造函數(shù)中sayName()的方法，person1和person2雖然都調(diào)用了這個方法，但是調(diào)用的并不是同一個Function實例。因此不同實例的同名函數(shù)是不相等的

alert(person1.sayName == person2.sayName);//false

然而創(chuàng)建兩個完成同樣任務(wù)的Function實例的確沒有必要；因此可以通過吧函數(shù)定義轉(zhuǎn)移到構(gòu)造函數(shù)外部來解決這個問題

function Person(name,age){
    this.name = name;
    this.age = age;
    this.sayName = sayName;
}
function sayName(){
    alert(this.name);
}
var person1 = new Person("liaojin",18);
var person2 = new Person("xiaoguan",20);

在構(gòu)造函數(shù)內(nèi)部，我們將sayName屬性設(shè)置為指向全局的sayName函數(shù)，由于sayName包含的是指向函數(shù)的指針，person1,person2共享了一個sayName函數(shù)，解決了兩個函數(shù)做同樣一件事的問題。
可是隨即有產(chǎn)生了新的問題：在全局作用域定義的函數(shù)實際上只能被某個對象調(diào)用，這讓全局函數(shù)優(yōu)點名不副實。如果對象需要定義很多方法，那么就需要定義多個全局函數(shù)，于是自定義的引用類型就沒有封裝性可言了，因此產(chǎn)生了原型模式。

我們所創(chuàng)建的每個函數(shù)都有一個prototype屬性，這個屬性是一個指針，指向一個對象，而這個對象的用途就是包含可以由特定類型的所有實例共享的屬性和方法。prototype就是通過調(diào)用構(gòu)造函數(shù)而創(chuàng)建的那個對象實例的原型對象?？梢宰屗袑ο蟮膶嵗蚕硭膶傩院头椒?。

function Person(){}
Person.prototype.name = "liaojin";
Person.prototype.age = 18;
Person.prototype.sayName = function(){
    alert(this.name);
};

var person1 = new Person();
Person1.sayName();//liaojin
var person2 = new Person();
Person2.sayName();//liaojin

alert(person1.sayName == person2.sayName);//true

構(gòu)造函數(shù)用于定義實例屬性，而原型模式用于定義方法和共享的屬性。這樣每個實例都會有自己的實例屬性的副本，但同時又共享著對方法的引用，最大限度地節(jié)省了內(nèi)存。

function Person(name,age){
    this.name = name;
    this.age = age;
    this.friends = ["lucy","lily"];
}

Person.prototype = {
    constructor:Person,
    sayName:function(){
        alert(this.name);
    }
}
var person1 = new Person("liaojin",18);
var person2 = new Person("xiaoguan",20);

person1.friends.push("lihua");
alert(person1.friends);//lucy,lily,lihua
alert(person2.friends);//lucy,lily
alert(person1.friends == person2.friends);//false
alert(person1.sayName == person2.sayName);//true

有其他面向?qū)ο蠼?jīng)驗開發(fā)的人員看到獨立的構(gòu)造函數(shù)和原型時，很可能會肥腸困惑，動態(tài)原型模式就是解決這個問題的一個方案。

function Person(name,age){
    this.name = name;
    this.age = age;
}
if(typeof this.sayName != "function"){
    Person.prototype.sayName = function(){
        alert(this.name);
    };
}

這里只在sayName()方法不存在的情況下才會將它添加到原型中。這段代碼只會在初期調(diào)用才會執(zhí)行。

這個模式可以在特殊的情況下用來為對象創(chuàng)建構(gòu)造函數(shù)。假設(shè)我們想創(chuàng)建一個具有額外方法的特殊數(shù)組。由于不能直接修改Array構(gòu)造函數(shù)，因此可以使用這個模式。

function SpecialArray(){
    var values = new Array();
    values.push.apply(values,arguments);
    values.toPipedString = function(){
        return this.join("|");
    };
    return values;
}
var colors = new SpecialArray["red","blue","green"];
alert(colors.toPipedString());//red|blue|green

說明：關(guān)于寄生構(gòu)造函數(shù)模式，首先返回的對象與構(gòu)造函數(shù)或者與構(gòu)造函數(shù)的原型屬性之間沒有關(guān)系；構(gòu)造函數(shù)返回的對象與在構(gòu)造函數(shù)外部創(chuàng)建的對象沒有什么不同。因此不能依賴instanceof操作符來確定對象的類型。

所謂穩(wěn)妥對象，指的是沒有公共屬性，而且其方法也不引用this的對象。穩(wěn)妥對象最適合在一些安全的環(huán)境中（禁止使用this和new的環(huán)境），或者在防止數(shù)據(jù)被其他應(yīng)用程序改動時使用。與寄生構(gòu)造函數(shù)類似的模式；但有兩點不同：1.新創(chuàng)建對象的實例方法不引用this；2.不使用new操作符調(diào)用構(gòu)造函數(shù)；

function Person(name,age){
    var o = new Object();
    o.sayName = function(){
    alert(name);
    };
    return o;
}

//使用
var friend = Person("liaojin",18);
friend.sayName();//liaojin

這樣變量person中保存的是一個穩(wěn)妥對象，而除了調(diào)用sayName()方法外，沒有別的方法可以訪問其數(shù)據(jù)成員，即使有其他代碼會給這個對象添加方法或數(shù)據(jù)成員，但也不可能有別的辦法訪問傳入到構(gòu)造函數(shù)中的原始數(shù)據(jù)，非常適合在某些安全執(zhí)行環(huán)境下使用。
與寄生構(gòu)造函數(shù)模式類似，使用穩(wěn)妥構(gòu)造函數(shù)模式創(chuàng)建的對象與構(gòu)造函數(shù)之間也沒有什么關(guān)系，因此instanceof操作符對這種對象也沒有什么意義