ECMA-262 把對象定義為:「無序屬性的集合,其屬性可以包含基本值、對象或者函數。」嚴格來說,這意味著對象是一組沒有特定順序的值,每個屬性都有一個名字並映射到一個值。因此可以把它想象成散列表——一組名值對,值可以是數據或函數。
創建自定義對象最簡單的方式是創建一個 Object 實例,再添加屬性和方法:
var person = new Object();
person.name = "liubei";
person.age = 29;
person.job = "shayemuyou";
person.sayName = function(){
alert(this.name);
}
早期開發者常用這種方式,後來對象字面量成為首選:
var person = {
name: "liubei",
age: 29,
job: "shayemuyou",
sayName: function(){
alert(this.name);
}
}
兩者創建的是同樣的對象。但它們有個明顯缺點:用同一接口創建多個對象會產生大量重復代碼。為了解決這個問題,人們開始使用各種模式。
一、工廠模式
工廠模式抽象了創建具體對象的過程。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 person1 = createPerson("wei", 25, "software");
var person2 = createPerson("bu", 25, "software");
工廠模式解決了創建多個相似對象的問題,但沒有解決對象識別問題——無法知道這是哪種類型的對象。
二、構造函數模式
像 Array、Object 這樣的原生構造函數會自動出現在執行環境中,我們也可以創建自定義構造函數來定義自定義類型:
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
alert(this.name);
}
}
var person1 = new Person("wei", 25, "software");
var person2 = new Person("bu", 25, "software");
Person() 與 createPerson() 的不同在於:沒有顯式創建對象、直接把屬性和方法賦值給 this、沒有 return 語句。此外要注意函數名 Person 首字母大寫——按慣例構造函數以大写字母開頭,非構造函數以小写字母開頭,這借鑒自其他 OO 語言。
用 new 操作符創建 Person 實例會經過四步:創建新對象、將構造函數作用域賦給新對象(this 指向新對象)、執行構造函數代碼、返回新對象。
console.log(person1.constructor == Person); // true console.log(person2.constructor == Person); // true console.log(person1 instanceof Object); // true console.log(person1 instanceof Person); // true
構造函數模式勝過工廠模式的地方,就在於能把實例標識為特定類型。但它的主要問題是每個方法都要在實例上重新創建一遍,造成內存浪費——person1 和 person2 的 sayName() 並不是同一個 Function 實例:
alert(person1.sayName == person2.sayName); // false
把函數定義移到構造函數外部可以解決,但又會污染全局作用域,且方法一多就毫無封裝性可言。這些問題可用原型模式解決。
三、原型模式
我們創建的每個函數都有一個 prototype(原型)屬性,它是一個指針,指向一個包含可由所有實例共享的屬性和方法的對象:
function Person(){
}
Person.prototype.name = "wei";
Person.prototype.age = 27;
Person.prototype.job = "Software";
Person.prototype.sayName = function(){
alert(this.name);
}
var person1 = new Person();
person1.sayName(); // "wei"
var person2 = new Person();
person2.sayName(); // "wei"
alert(person1.sayName == person2.sayName); // true
與構造函數不同,新對象的屬性和方法由所有實例共享。原型模式的缺點是省略了傳遞參數的環節,所有實例默認擁有相同屬性值;而最大的問題在於共享本質——對包含引用類型值的屬性來說,問題就很突出:
function Person(){ }
Person.prototype = {
constructor: Person,
name: "wei",
age: 29,
friends: ["乾隆","康熙"],
sayName: function(){
alert(this.name);
}
}
var person1 = new Person();
var person2 = new Person();
person1.friends.push("嬴政");
console.log(person1.friends); // ["乾隆","康熙","嬴政"]
console.log(person2.friends); // ["乾隆","康熙","嬴政"]
console.log(person1.friends === person2.friends); // true
因為 friends 存在於 prototype 中而非 person1 中,所以修改 person1.friends 會連帶影響 person2。因此很少單獨使用原型模式。
四、組合使用構造函數模式和原型模式
創建自定義類型最常見的方式就是組合兩者:構造函數模式定義實例屬性,原型模式定義方法和共享屬性。每個實例都有自己的實例屬性副本,同時又共享方法的引用,最大限度節省內存,還支持傳遞參數:
function Person(name, age){
this.name = name;
this.age = age;
this.friends = ["乾隆","康熙"];
}
Person.prototype = {
constructor: Person,
sayName: function(){
alert(this.name);
}
}
var person1 = new Person("wei", 29);
var person2 = new Person("bu", 25);
person1.friends.push("嬴政");
console.log(person1.friends); // ["乾隆","康熙","嬴政"]
console.log(person2.friends); // ["乾隆","康熙"]
console.log(person1.friends === person2.friends); // false
console.log(person1.sayName === person2.sayName); // true
修改 person1.friends 不會影響 person2,因為它們引用不同數組。這種混成模式是目前在 ECMAScript 中使用最廣泛、認同度最高的定義引用類型的方式。
五、動態原型模式
動態原型模式把所有信息封裝在構造函數中,並在構造函數中初始化原型(僅在必要時),同時保持構造函數和原型的優點。做法是檢查某個應該存在的方法是否有效,來決定是否初始化原型:
function Person(name, age){
this.name = name;
this.age = age;
this.friends = ["乾隆","康熙"];
// 注意 if 語句
if(typeof this.sayName != "function"){
Person.prototype.sayName = function(){
alert(this.name);
}
}
}
var person1 = new Person("wei", 29);
person1.friends.push("嬴政");
person1.sayName();
if 語句只在 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 person = new Person("wei", 29, "banzhuan");
person.sayName(); // "wei"
除了用 new 調用外,這個模式與工廠模式並無多大區別——在構造函數末尾加 return 語句可以重寫返回值。它可以在特殊情況下為對象創建構造函數,比如創建帶額外方法的特殊數組:
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");
console.log(colors.toPipedString()); // red|blue|green
需要注意的是:返回的對象與構造函數或其原型沒有任何關系,因此不能依賴 instanceof 判斷類型。能用其他模式時盡量別用它。
七、穩妥構造函數模式
道格拉斯·克拉克福德發明了穩妥對象的概念。所謂穩妥對象,是指沒有公共屬性、方法也不引用 this 的對象,最適合在禁止使用 this 和 new 的安全環境中使用。它與寄生構造函數模式有兩點不同:新對象的方法不引用 this、不使用 new 調用:
function Person(name, age, job){
// 創建要返回的新對象
var o = new Object();
// 可在這裡定義私有變量和函數
// 添加方法
o.sayName = function(){
alert(name);
}
// 返回對象
return o;
}
var person = Person("weiqi", 22, "banzhuan");
person.sayName(); // weiqi
除了 sayName() 方法外,沒有別的方式訪問 name 的值。即使有其他代碼給對象添加方法或數據成員,也不可能訪問到傳入構造函數的原始數據。這種安全性使它非常適合在 ADsafe 等安全執行環境下使用。與寄生構造函數模式類似,穩妥構造函數創建的對象與構造函數之間沒有關系,instanceof 對它也沒有意義。