DIV CSS 佈局教程網

JavaScript 建立物件的八種經典寫法完整解析
編輯:關於JavaScript     

在 JavaScript 的學習路徑上,「如何建立物件」可說是必須跨過的第一道門檻。從最直覺的建構函式,到兼顧效能與封裝的組合模式,一共有八種常見思路。本文將逐一梳理,帶你理解每種寫法背後的取捨與適用情境。

一、使用 Object 建構函式建立物件

最樸素的做法,就是呼叫 Object 建構函式,接著逐一掛上屬性。屬性既可以點號取值,也可以用中括號搭配字串取值,兩者效果一致。

 var person = new Object(); person.name="kevin"; person.age=31; alert(person.name); alert(person["name"])

與之等價的是物件字面量寫法,程式碼更精簡。別被 person["5"] 嚇到,用數字當索引完全合法;只要改用中括號,欄位名稱甚至能帶有空白,例如 person["my age"]。

 var person = { name:"Kevin", age:31, 5:"Test" }; alert(person.name); alert(person["5"]);

無論是建構函式還是字面量,都能勝任單個物件的建立,但缺點同樣明顯:當你想大量生產結構相同的物件時,就會產生一堆重複的程式碼。為了解決這個痛點,工程師借鑑了工廠模式。

二、工廠模式

工廠模式是軟體工程裡家喻戶曉的設計模式,它把「建立具體物件的過程」抽象出來。由於 ECMAScript 天生沒有 class,工程師便用一個函式把建立物件的細節封裝起來。

 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("Nicholas", 29, "Software Engineer"); var person2 = createPerson("Greg", 27, "Doctor");

工廠模式確實省下了重複建立多個相似物件的力氣,卻留下了一個懸念:它無法辨識物件的類型(也就是說,你無從得知某個物件到底屬於哪一種)。隨著語言演進,下一個模式應運而生。

三、建構函式模式

像 Object、Array 這類內建建構函式,會在執行環境啟動時自動就位。除此之外,我們也能自訂建構函式,用來描述自訂物件型別的屬性與方法。把前面的例子改寫如下即可看出差異。

 function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.sayName = function(){ alert(this.name); }; } var person1 = new Person("Nicholas", 29, "Software Engineer"); var person2 = new Person("Greg", 27, "Doctor");

這裡以 Person() 取代了 createPerson(),但寫法上有三個關鍵轉變:

1、沒有明確地建立物件;
2、直接把屬性與方法掛在 this 上;
3、省略了 return 敘述。

要產生 Person 的新實例,必須搭配 new 運算子。以這種方式呼叫建構函式,背後其實會走過四個步驟:

(1) 建立一個全新物件;
(2) 把建構函式的作用域交給這個新物件(於是 this 便指向它);
(3) 執行建構函式內的程式碼,為新物件添上屬性;
(4) 回傳這個新物件。

執行到最後,person1 與 person2 各自保存著一個獨立的 Person 實例。兩者都帶有 constructor 屬性,且都指向 Person:

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

constructor 屬性的初衷是用來標示物件型別。不過若真要檢測型別,instanceof 運算子會更可靠。此例中建立的所有物件,既是 Object 的實例,同時也是 Person 的實例,這點可透過 instanceof 獲得驗證。

alert(person1 instanceof Object); //true
alert(person1 instanceof Person); //true
alert(person2 instanceof Object); //true
alert(person2 instanceof Person); //true

自訂建構函式的意義,在於未來能把它的實例標記為某種特定型別——這正是建構函式模式勝過工廠模式之處。而 person1、person2 之所以同時是 Object 的實例,是因為所有物件都繼承自 Object。

建構函式的問題

建構函式模式雖好用,卻非毫無瑕疵。它最大的毛病是:每個方法都得在每個實例上重新建立一次。

在 ECMAScript 中,函式本身就是物件,因此每宣告一個函式,等於多了一個物件實例。從這個角度看,前面的建構函式也可以改寫成這樣:

function Person(name, age, job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = new Function("alert(this.name)"); // 與宣告函式在邏輯上等價
}

換個角度理解,就更容易看清本質:每個 Person 實例其實都各自包著一個不同的 Function 實例(負責顯示 name)。也就是說,以這種方式產生的函式會各自擁有獨立的作用域鏈與識別字解析,但建立 Function 新實例的機制始終相同。因此,不同實例上的同名函式並不相等,以下程式碼便是明證。

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

然而,為兩個負責相同任務的 Function 實例各建一份,顯然多此一舉;更何況有 this 在,根本不必事先把函式綁定到特定物件上。於是,把函式定義搬到建構函式外部,就成了合理的解法。

 function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.sayName = sayName; } function sayName(){ alert(this.name); } var person1 = new Person("Nicholas", 29, "Software Engineer"); var person2 = new Person("Greg", 27, "Doctor");

問題在於,一旦物件需要大量方法,就得宣告一大堆全域函式,自訂的參考型別也就談不上什麼封裝了。所幸,這些困擾都能靠原型模式化解。

四、原型模式

 function Person(){ } Person.prototype.name = "Nicholas"; Person.prototype.age = 29; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function(){ alert(this.name); }; var person1 = new Person(); person1.sayName(); //"Nicholas" var person2 = new Person(); person2.sayName(); //"Nicholas" alert(person1.sayName == person2.sayName); //true 

前面每新增一個屬性或方法,就得重敲一次 Person.prototype。為了少打字、也為了在視覺上更緊湊地封裝原型,實務上更常見的做法,是用一個包含所有屬性與方法的物件字面量,一次重寫整個原型。

 function Person(){ } Person.prototype = { name : "Nicholas", age : 29, job: "Software Engineer", sayName : function () { alert(this.name); } };

這段程式碼把 Person.prototype 設為一個以字面量建立的新物件,最終效果相同,卻有一個例外:constructor 屬性不再指向 Person。前面提過,每建立一個函式,就會同時產生它的 prototype 物件,而這個物件會自動獲得 constructor 屬性。但我們現在等於把預設的 prototype 整個換掉,於是 constructor 也變成新物件的 constructor(指向 Object 建構函式),不再指向 Person。此時,即便 instanceof 仍能回傳正確結果,卻已無法靠 constructor 判定型別。

 var friend = new Person(); alert(friend instanceof Object); //true alert(friend instanceof Person); //true alert(friend.constructor == Person); //false alert(friend.constructor == Object); //true

這裡用 instanceof 測試 Object 與 Person 都回傳 true,但 constructor 卻等於 Object 而非 Person。如果 constructor 的值對你很重要,可以特意把它設回正確的值。

 function Person(){ } Person.prototype = { constructor : Person, name : "Nicholas", age : 29, job: "Software Engineer", sayName : function () { alert(this.name); } };

這裡要牢記一點:實例中的指標只指向原型,並不指向建構函式。

原型模式的問題在於:它省掉了「為建構函式傳入初始化參數」的環節,導致所有實例預設都拿到相同的屬性值。這雖帶來些許不便,卻還不是最麻煩的地方。原型模式真正的痛點,源自它「共享」的本性。

 function Person(){ } Person.prototype = { constructor: Person, name : "Nicholas", age : 29, job : "Software Engineer", friends : ["Shelby", "Court"], sayName : function () { alert(this.name); } }; var person1 = new Person(); var person2 = new Person(); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Court,Van" alert(person2.friends); //"Shelby,Court,Van" alert(person1.friends === person2.friends); //true 

五、組合使用建構函式模式與原型模式(最常用)

建立自訂型別最普遍的方式,就是把建構函式模式與原型模式搭配使用:前者負責定義實例屬性,後者負責定義方法與共享屬性。如此一來,每個實例都擁有一份自己的實例屬性副本,同時又共用同一份方法參照,內存使用達到最佳化。更棒的是,這種混搭還支援向建構函式傳參,可謂集兩者之長。

 function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.friends = ["Shelby", "Court"]; } Person.prototype = { constructor : Person, sayName : function(){ alert(this.name); } } var person1 = new Person("Nicholas", 29, "Software Engineer"); var person2 = new Person("Greg", 27, "Doctor"); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Count,Van" alert(person2.friends); //"Shelby,Count" alert(person1.friends === person2.friends); //false alert(person1.sayName === person2.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 friend = new Person("Nicholas", 29, "Software Engineer"); friend.sayName(); 

七、寄生建構函式模式

當前面幾種模式都不合用時,可以考慮寄生(parasitic)建構函式模式。它的核心思路是:建立一個函式,其唯一職責是封裝建立物件的程式碼,然後回傳這個新物件;但從外觀上看,它又像極了典型的建構函式。

 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 friend = new Person("Nicholas", 29, "Software Engineer"); friend.sayName(); //"Nicholas"

此例中,Person 建立一個新物件、賦予對應的屬性與方法,再把它回傳。除了使用 new 並把包裝函式取名為建構函式之外,這個模式其實和工廠模式一模一樣。而未回傳值的建構函式,預設會回傳新的物件實例。

八、穩妥建構函式模式

所謂穩妥物件,指的是沒有公開屬性、且方法也不參照 this 的物件。這類物件最適合部署在安全環境中(那些環境會禁用 this 與 new),或者用於防止資料被其他應用程式(例如 Mashup)竄改。穩妥建構函式與寄生建構函式相似,但有兩點不同:其一,新物件的實例方法不參照 this;其二,呼叫建構函式時不使用 new。依此要求,可把前面的 Person 改寫如下。

 function Person(name, age, job){ //建立要回傳的物件 var o = new Object(); //可以在這裡定義私有變數和函式 //添加方法 o.sayName = function(){ alert(name); }; //返回物件 return o; } 
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved