DIV CSS 佈局教程網

JavaScript 對象:創建對象的 7 種模式详解
編輯:JavaScript基礎知識     

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 對它也沒有意義。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved