摘要：用對象字面量形式創建的對象，直接賦值給函數的原型對象，本質上完全重寫了其對象，因此屬性也就變成了新對象的屬性指向構造函數，不再指向函數。

【上一篇】：JavaScript對象內部屬性及其特性總結

先在內部顯示地創建一個臨時對象，根據接收的參數來構建（賦值屬性和方法）該對象，并返回該對象。
缺點：沒有解決對象識別的問題（即無法確認一個對象的類型）。

function PersonFactory (name, age){
    var o = new Object();
    o.name = name;
    o.age = age;
    o.sayName = function(){
        console.log(this.name)
    }
    return o;
}

var p1 = PersonFactory();
var p2 = PersonFactory();
p1 instanceof Object; // true
p2 instanceof Object; // true
p1 instanceof PersonFactory; // false  無法識別具體對象類型
p2 instanceof PersonFactory; // false

函數名首字母一般大寫（如：Person，借鑒OO語言命名習慣）區別于其他函數；
構造函數本身也是函數，只不過可以用來參加對象而已；
每個新建的實例對象都有一個constructor屬性，該屬性指向構造函數自身Person；

構造函數也可以被當做普通函數來調用；
在全局作用域中調用一個函數時，this對象總是指向Global對象（瀏覽器中即window對象）


【優點】自定義構造函數可以將它的實例標識為一種特定的類型；

【缺點】構造函數的主要問題是，每個方法都要在每個實例上重新創建一遍；

創建（隱式地）一個新對象；
將構造函數的新對象賦值給新對象（此時this指向這個新對象）；
執行構造函數中的代碼（為這個新對象添加屬性）；
返回新對象（該構造函數的實例）；

沒有顯示地創建對象；
直接將屬性和方法賦值給this對象；
沒有return語句；

優點：可以確認具體對象類型；

function Person (name, age){
    this.name = name;
    this.age = age;
    this.sayName = function(){
        console.log(this.name);
    }
}
// 當做普通函數
var p1 = new Person("Tom", 20);
var p2 = new Person("Greg", 30);
p1 instanceof Object;         // true
p2 instanceof Object;         // true
p1 instanceof PersonFactory;  // true 可以確認具體對象類型
p2 instanceof PersonFactory;  // true

// 作為普通函數調用
Person("Green", 30);  // 屬性和方法都被添加到window對象了
window.sayName();     // "Green"

// 在另一個對象的作用域中調用
var obj = new Object();
Person.call(obj , "Jim", 23);
obj .sayName(); // "Jim"

構造函數變為空函數；
將所有屬性和方法都添加到了構造函數的prototype屬性中；

不同：新對象的屬性和方法由所有實例共享（p1和p2訪問的都是同一組屬性和同一個函數）；

function Person(){}

Person.prototype.name = "Tom";
Person.prototype.age = 24;
Person.prototype.sayName = function(){
    console.log(this.name);
}

var p1 = new Person(), p2 = new Person();
p1.sayName();// "Tom"
p2.sayName();// "Tom"
console.log(p1.sayName === p2.sayName);// true

每創建一個函數，就會同時創建它的prototype對象，該prototype對象也會自動獲得constructor屬性。
用對象字面量形式創建的對象，直接賦值給函數的原型對象（Person.prototype），本質上完全重寫了其prototype對象，
因此constructor屬性也就變成了新對象的constructor屬性（指向Object構造函數），不再指向Person函數。
此時instanceof操作符可以返回正確結果，但通過constructor已經無法確定對象類型了。

function Person(){}
Person.prototype = {
    // construtor : Person, // 需要重新指設constructor屬性
    name : "Tom",
    age : 24,
    sayName : function(){
        console.log(this.name);
    }
}

var p = new Person(); 
console.log(p instanceof Object); // ture
console.log(p instanceof Person); // ture
console.log(p.construtor == Object); // ture
console.log(p.construtor == Person); // false

以上述方式重設constructor屬性會導致它的[[Enumerable]]特性被設置為true;
默認情況下，原生的constructor屬性是不可枚舉的；
因此可利用Object.defineProperty()重設；

Object.defineProperty(Person.prototype, "constructor", {
    enumerable : false,
    value : Person
});

定義

組合使用構造函數模式和原型模式；
構造函數模式用于定義實例屬性，原型模式用于定義方法和共享的屬性；



優點：

每個實例都會有自己的一份實例屬性的副本，同時又共享著對方方法的引用，最大限度節省了內存；
這種混成模式支持向構造函數傳遞參數；


目前使用最廣泛、認同度最高的一種自定義類型的方法，可以說是用來定義引用類型的一種默認模式；

// 實例屬性均在構造函數中定義
function Person(name, age){
    this.name = name;
    this.age = age;
    this.friends = ["Nicholas", "Jim"];
}
// 由所有實例共享屬性constructor和方法則是在原型中定義的
Person.prototype = {
    construtor: Person,
    sayName: function(){
        console.log(this.name);
    }
}

var p1 = new Person("Tom", 25);
var p2 = new Person("Greg", 26);
p1.friends.push("Tony");
console.log(p1.friends); // ["Nicholas", "Jim", "Tony"]
console.log(p2.friends); // ["Nicholas", "Jim"]
console.log(p1.friends === p2.friends); // false
console.log(p1.sayName === p2.sayName); // true

定義：

動態原型模式把所有信息都封裝在了構造函數中；
通過在構造函數中初始化原型（僅在必要的情況下，比如第一次新建實例時）；
通過檢查某個應該存在（原型中）的方法是否有效，來決定是否需要初始化原型；



優點：保持了同時使用構造函數和原型的特點；

下段代碼中只會在初次調用構造函數時才會執行，此后原型已經完成初始化，無需再做修改；
這里對原型所做對修改，能夠立即在所有實例中得到反映；

if語句檢查的可以是初始化之后應該存在的任何屬性或方法，檢查其中一個即可；

function Person(name, age){
    // 屬性
    this.name = name;
    this.age = age;
    // 方法
    if(typeof this.sayName != "function"){
        Person.prototype.sayName = function(){
            console.log(this.name);
        }
    }
}

【定義】: 基本思想是創建一個函數，該函數的作用僅僅是封裝創建對象的代碼，然后再返回新創建的對象。

【特點】：

返回的對象與構造函數或者與構造函數的原型屬性之間沒有關系；
寄生構造函數返回的對象與在寄生構造函數外部創建的對象沒有什么不同；
不能依賴instanceof操作符來確定對象類型；

除了使用new操作符并把使用的包裝函數叫做構造函數之外，該模式和工廠模式其實是一模一樣的；

從表面上看，很像典型的構造函數；

構造函數在不返回值的情況下，默認會返回新對象實例；

而寄生構造函數通過在構造函數的末尾加一個return語句，重寫了調用構造函數時返回的值；
此時返回的對象的__proto__屬性指向Object;

function Person(name, age){
    // 創建臨時新對象
    var o = new Object();
    // 初始化該對象
    o.name = name;
    o.age = age;
    o.sayName = function(){
        console.log(this.name);
    }
    // 返回該臨時新對象
    return o;
}

var p1 = new Person("Tom", 25);
var p2 = new Person("Greg",30);
console.log(p1 instanceof Object); // true
console.log(p1 instanceof Person); // false
console.log(p1.sayName == p2.sayName); // false
console.log(p1.constructor == Object); //true

所謂穩妥對象，就是指沒有公共屬性，而且其方法也不引用this的對象。
穩妥對象最適合在一些安全的環境中（這些環境會禁用this和new）,或者防止數據被其他應用程序改動時調用。

與寄生構造函數類似，但又不同：

一是新創建的對象實例方法不引用this;
二是不使用new操作符調用構造函數；

function Person (name, age){
    var o = new Object();
    // 可定義私有變量和函數
    // ...
    
    // 新創建的對象實例方法未引用this;
    o.sayName = function(){
        console.log(name)
    }
    return o;
}

var p = Person("Tom", 23);
p.sayName(); // "Tom"
console.log(p instanceof Person); // false

除了sayName()方法外，沒有別的方法可以訪問其數據成員；
即使有其他代碼給這個對象添加方法或數據成員，也不可能有別的辦法訪問傳入到構造函數中的原始數據；
與寄生構造函數模式類似，使用穩妥構造函數模式創建的對象與構造函數之間也沒有關系(故instanceof操作符對這種對象也無意義)；