Object構造函數或對象字面量可以用來創建單個對象，但是有明顯的缺點：使用同一個接口創建很多對象，會產生大量的重復代碼。
因此，可以考慮使用設計模式來創建對象。
工廠模式
抽象了創建具體對象的過程。
在ECMAScript中無法創建類，開發人員就發明了一種函數，用函數來封裝以待定接口創建對象的細節。
function createPerson(name,age,job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName=function(){
alert(this.name);
};
return o;
}
var p1 = createPerson("wonder",23,"student");
缺點：雖然解決了創建多個相似對象的問題，但沒有解決對象識別的問題（即怎樣知道一個對象的類型）。
構造函數模式
創建自定義的構造函數，從而定義自定義對象類型的屬性和方法。
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayName=function(){
alert(this.name);
};
}
var p1 = new Person("wonder",23,"student");
與工廠模式的不同：
- 沒有顯示地創建對象；
- 直接將屬性和方法賦給this對象；
- 沒有return語句
與工廠模式相比的優點：
創建自定義的構造函數意味著將來可以將它的實例標識為一種特定的類型。
注意：構造函數始終都應該以一個大寫字母開頭，而非構造函數則應該以一個小寫字母開頭。為了區別其它函數：因為構造函數本身也是函數，只不過可以用來創建對象。
要創建Person的新實例，必須使用new操作符。
檢測對象類型，用instanceof操作符比較可靠。
alert(p1 instanceof Object); //true
alert(p1 instanceof Person); //true
1、將構造函數當做函數
構造函數與其他函數的唯一區別：調用它們的方式不同。
任何函數，只要通過new操作符來調用，那它就可以作為構造函數；而任何函數，如果不通過new操作符來調用，那它跟普通函數不會有什么兩樣。
//構造函數使用
var person = new Person("wonder",23,"student");
person.sayName(); //"wonder"
//普通函數調用
Person("wonder",23,"student"); //添加到window
window.sayName(); //"wonder
//在另一個對象的作用域中調用
var o = new Object();
Person.call(o,"Abby",25,"Nurse");
o.sayName(); //"Abby"
2、構造函數的問題
使用構造函數的缺點：每個方法都要在每個實例上重新創建一遍。因此不同實例上的同名函數是不相等的。
var p1 = new Person("wonder",23,"student");
var p2 = new Person("Abby",25,"Nurse");
alert(p1.sayName == p2.sayName); //false
但是，創建兩個完成同樣任務的Function實例沒有必要。因此可以通過把函數定義轉移到構造函數外部來解決這個問題：
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayName= sayName;
}
function sayName(){
alert(this.name);
}
但是這樣也有缺點：若對象需要定義很多方法，那就要定義很多個全局函數，因此這個自定義的引用類型就沒有封裝性可言了。
原型模式可以解決這個問題。
原型模式
創建的每個函數都有一個prototype（原型）屬性，這個屬性是一個指針，指向一個對象，這個對象的用途是包含可以由特定類型的所有實例共享的屬性和方法。
優點：可以讓所有對象實例共享它所包含的屬性和方法。
function Person(){
}
Person.prototype.name = "wonder";
Person.prototype.age = 23;
Person.prototype.job = "student";
Person.prototype.sayName = function(){
alert(this.name);
};
var p1 = new Person();
p1.sayName(); //"student"
var p2 = new Person();
p2.sayName(); //"student"
alert(p1.sayName == p2.sayName); //true
不能通過對象實例重寫原型中的值。如果在實例中添加了一個屬性，而該屬性與實例原型中的一個屬性同名，那在實例中間就會創建該屬性，該屬性將會屏蔽原型中的那個屬性。
function Person(){
}
Person.prototype.name = "wonder";
Person.prototype.age = 23;
Person.prototype.job = "student";
Person.prototype.sayName = function(){
alert(this.name);
};
var p1 = new Person();
var p2 = new Person();
p1.name = "Greg";
alert(p1.name); //"Greg"——來自實例
alert(p2.name); //"wonder"——來自原型
不過，使用delete操作符可以完全刪除實例屬性，從而能夠重新訪問原型中的屬性。
function Person(){
}
Person.prototype.name = "wonder";
Person.prototype.age = 23;
Person.prototype.job = "student";
Person.prototype.sayName = function(){
alert(this.name);
};
var p1 = new Person();
var p2 = new Person();
p1.name = "Greg";
alert(p1.name); //"Greg"——來自實例
alert(p2.name); //"wonder"——來自原型
delete p1.name;
alert(p1.name); //"wonder"——來自原型
1、方法isPrototypeOf()可以確定對象之間是否存在關系。如果[[Prototype]]指向調用isPrototypeOf()方法的對象，則方法返回true。
alert(Person.prototype.isPrototypeOf(p1)); //true
alert(Person.prototype.isPrototypeOf(p2)); //true
2、hasOwnProperty()方法可以檢測一個屬性是存在于實例中，還是存在于原型中。這個方法只在給定屬性存在于對象實例中時，才會返回true。
function Person(){
}
Person.prototype.name = "wonder";
Person.prototype.age = 23;
Person.prototype.job = "student";
Person.prototype.sayName = function(){
alert(this.name);
};
var p1 = new Person();
var p2 = new Person();
alert(p1.hasOwnProperty("name")); //false
p1.name = "Greg";
alert(p1.name); //"Greg"——來自實例
alert(p1.hasOwnProperty("name")); //true
delete p1.name;
alert(p1.hasOwnProperty("name")); //false
in操作符
in除了在for-in循環中使用之外，還能單獨使用。單獨使用時，in操作符會在通過對象能夠訪問給定屬性時返回true，無論該屬性存在于實例中還是原型中。
function Person(){
}
Person.prototype.name = "wonder";
Person.prototype.age = 23;
Person.prototype.job = "student";
Person.prototype.sayName = function(){
alert(this.name);
};
var p1 = new Person();
var p2 = new Person();
alert(p1.hasOwnProperty("name")); //false
alert("name" in p1); //true
p1.name = "Greg";
alert(p1.name); //"Greg"——來自實例
alert(p1.hasOwnProperty("name")); //true
alert("name" in p1); //true
delete p1.name;
alert(p1.name); //"wonder"——來自原型
alert(p1.hasOwnProperty("name")); //false
alert("name" in p1); //true
同時使用in操作符和hasOwnProperty()方法，就可以確定屬性是存在于對象中，還是存在于原型中：
function hasPrototypeProperty(object,name){
return !object.hasOwnProperty(name) && (name in object);
}
Object.keys()
用途：可以獲取對象上所有可枚舉的實例屬性。
param：一個對象
return：包含所有可枚舉屬性的字符串數組
支持：IE9+、Firefox 4+、Safari 5+、Opera 12+ 和 Chrome
function Person(){
}
Person.prototype.name = "wonder";
Person.prototype.age = 23;
Person.prototype.job = "student";
Person.prototype.sayName = function(){
alert(this.name);
};
var keys = Object.keys(Person.prototype);
alert(keys); //"name,age,job,sayName"
var p1 = new Person();
p1.name = "Rob";
p1.age = 31;
var p1keys = Object.keys(p1);
alert(p1keys); //"name,age"
Object.getOwnPropertyNames()
用途：得到所有實例屬性，無論是否可枚舉。
param：一個對象
return：包含所有實例屬性的字符串數組
支持：IE9+、Firefox 4+、Safari 5+、Opera 12+ 和 Chrome
var keys = Object.getOwnPropertyNames(Person.prototype);
alert(keys); //"constructor,name,age,job,sayName"
簡化原型語法
function Person() {
}
Person.prototype = {
name:'wonder',
age:23,
job:'student',
sayName:function(){
alert(this.name);
}
};
這樣的語法，本質上完全重寫了默認的prototype對象，因此constructor屬性也就變成了新對象的constructor屬性（指向Object構造函數），不再指向Person函數。
var friend = new Person();
alert(friend instanceof Object); //true
alert(friend instanceof Person); //true
alert(friend.constructor == Person); //false
alert(friend.constructor == Object); //true
如果constructor的值很重要，則可以特意設置回適當的值。但是會導致它的[[Enumerable]]特性被設置為true。默認情況下，原生的constructor屬性是不可枚舉的，因此可以用Object.defineProperty()。
function Person() {
}
Person.prototype = {
constructor:Person,
name:'wonder',
age:23,
job:'student',
sayName:function(){
alert(this.name);
}
};
//重設構造函數，只適用于ECMAScript 5兼容的瀏覽器。
Object.defineProperty(Person.propotype,"constructor",{
enumerable:false,
value:Person
});
重寫原型對象會切斷現有原型與任何之前已經存在的對象實例之間的聯系。
function Person() {
}
var friend = new Person();
Person.prototype = {
name:'wonder',
age:23,
job:'student',
sayName:function(){
alert(this.name);
}
};
friend.sayName(); //error
原型模式的缺點
1.省略了為構造函數傳遞初始化參數環節，所有實例在默認情況下都將取得相同的屬性值。
2.原型中所有屬性被很多實例共享，因此對于包含引用類型值的屬性來說，會產生問題：
function Person(){
}
Person.prototype = {
constructor:Person,
name:'wonder',
age:23,
job:'student',
friends:["Abby","Court"],
sayName:function(){
alert(this.name);
}
};
var p1 = new Person();
var p2 = new Person();
p1.friends.push("Lucy");
alert(p1.friends); //"Abby,Court,Lucy"
alert(p2.friends); //"Abby,Court,Lucy"
alert(p1.friends == p2.friends); //true
組合使用構造函數模式和原型模式
構造函數模式用于定義實例屬性，而原型模式用于定義方法和共享的屬性。
組這種模式是用來定義引用類型的一種默認模式。
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.friends=["Abby","Court"];
}
Person.prototype = {
constructor:Person,
sayName:function(){
alert(this.name);
}
};
var p1 = new Person("Wonder",23,"student");
var p2 = new Person("Lucy",29,"nurse");
p1.friends.push("Van");
alert(p1.friends); //"Abby,Court,Van"
alert(p2.friends); //"Abby,Court"
alert(p1.friends == p2.friends); //false
alert(p1.sayName == p2.sayName); //true
動態原型模式
把所有信息都封裝在構造函數中，通過在構造函數中初始化原型（僅在必要的情況下），又保持了同時使用構造函數和原型的優點。——可以通過檢查某個應該存在的方法是否有效，來決定是否需要初始化原型。
function Person(name,age,job){
//屬性
this.name = name;
this.age = age;
this.job = job;
//方法
if(typeof this.sayName!= "function"){
Person.prototype.sayName = function(){
alert(this.name);
}
}
}
var p1 = new Person("Wonder",23,"student");
p1.sayName();
寄生構造函數模式
基本思想：創建一個函數，該函數的作用僅僅是封裝創建對象的代碼，然后再返回新創建的對象。
function Person(name,age,job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
}
return o;
}
var p1 = new Person("Wonder",23,"student");
p1.sayName();
穩妥構造函數模式
穩妥對象——指的是沒有公共屬性，而且其方法也不引用this的對象。
試用：最適合在一些安全的環境中（這些環境中會禁止試用this和new），或者在防止數據被其他應用程序改動時試用。
穩妥構造函數與寄生構造函數有類似的模式，但有兩點不同：
- 新創建對象的實例方法不引用this
- 不適用new操作符調用構造函數
function Person(name,age,job){
//創建要返回的對象
var o = new Object();
//可以在這里定義私有變量和函數
//添加方法
o.sayName = function(){
alert(name);
}
return o;
}
var p1 = new Person("Wonder",23,"student");
p1.sayName();
這樣變量p1中保存的是一個穩妥對象，除了調用sayName()方法外，沒有別的方式可以訪問其數據成員。
