JavaScript 建立物件的方式很多,寫起來非常靈活。那麼究竟哪一種最恰當?建構模式、原型模式,還是物件字面量模式?要回答這個問題,得先把幾個基礎觀念理清。
可以。JavaScript 能建立物件,這種物件可以包含資料、能操作資料的方法,甚至包含其他物件。它沒有 class 關鍵字,但有建構函式;它沒有類別繼承機制,但可以透過原型(prototype)實作繼承。
另外要記住 JavaScript 有私有變數:用 var 宣告的變數只能在函式主體內存取。那如果不加 var 呢?那會變成全域(或掛到 this 上,視上下文而定),這個題目這裡先不展開。
複製代碼 代碼如下:
var Person = {
firstName : 'John',
lastName : 'Cody',
fullName : '',
message : '',
createFullName : function () {
fullName = this.firstName + ' ' + this.lastName;
},
changeMessage : function (msg) {
this.message = msg;
},
getMessage : function () {
this.createFullName();
return this.message + ' ' + fullName;
}
}
Person.firstName = 'Eli';
Person.lastName = 'Flowers'
Person.changeMessage('welcome');
var message = Person.getMessage(); // welcome Eli Flowers
alert(message);
這就是物件字面量模式,很接近我們平常建立物件的方式。如果你不需要在意私有/封裝的成員,也確定不會建立這個物件的實例,那麼這種方式很合適——公有成員本來就能做私有成員的事。但請注意:這不是類別,只是一個物件,既不能建立實例,也不能被繼承。
換個角度,用 function 來寫:
複製代碼 代碼如下:
var Person = function (firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
this.fullName = '';
this.message = '';
this.createFullName = function () {
this.fullName = this.firstName + ' ' + this.lastName;
};
this.changeMessage = function (msg) {
this.message = msg;
};
this.getMessage = function () {
this.createFullName();
return this.message + ' ' + this.fullName;
};
}
var person = new Person('Eli', 'Flowers');
person.changeMessage('welcome');
alert(person.getMessage());
這算類別還是物件?兩者都算。可以把它當作普通函式使用,但它畢竟只是一個函式;而透過 new 關鍵字,它能建立新的實例。
1. 函式被呼叫時,永遠有一個特別的變數 this,其指向取決於呼叫方式(在全域呼叫時指向全域物件)。
2. 用 new 建立實例時,this 指向這個新建立的物件,而且 new 會改變函式主體中程式碼的執行方式——這正是建構模式的核心。
3. 掛在 this 上的變數會成為公有屬性;用 var 宣告的則是私有屬性。
4. 掛在 this 上的函式叫「特權函式」,它能存取所有私有變數,以及掛在 this 上的函式與變數。
5. 私有函式可以存取其他私有變數與私有函式。
6. 私有函式不能直接存取掛在 this 上的成員。繞道方法是先建一個私有變數(例如 var _that = this;)再透過它存取。
7. 任何私有變數與函式,對其他私有函式以及掛在 this 上的函式都是可用的。
8. 一個變數若既沒有 var、也沒掛在 this 上,就會取得全域作用域。這通常需要額外留意。
這個模式已經滿足大部分需求,但 this 與 that 這兩個入口變數容易搞混,對追求純粹私有的人尤其困擾。
再調整一下,把 getter/setter 明確暴露出來(這個模式出自 Christian Heilmann):
複製代碼 代碼如下:
var Person = function () {
//private
var firstName = 'John';
var lastName = 'Cody';
var fullName = '';
var message = '';
var createFullName = function () {
fullName = firstName + ' ' + lastName;
}
//public setters
var setMessage = function (msg) {
message = msg;
}
var setFirstName = function (fName) {
firstName = fName;
}
var setLastName = function (lName) {
lastName = lName;
}
var getMessage = function () {
createFullName();
return message + ' ' + fullName;
}
//functions exposed public
return {
setFirstName: setFirstName,
setLastName: setLastName,
setMessage: setMessage,
getMessage: getMessage
};
};
var person1 = new Person();
person1.setFirstName('Eli');
person1.setLastName('Flowers');
person1.setMessage('welcome');
var message = person1.getMessage(); // welcome Eli Flowers
alert(message);
這個模式大部分方面都做得很好,只留一個小問題:每次建立實例,這個新物件都會獲得一份變數與函式的完整拷貝。變數被複製沒問題——我們本來就希望每個物件擁有自己的資料;但成員函式呢?它們做的只是操作資料的操作,為什麼也要複製?
這正是原型模式(Prototype)的價值所在:所有東西都建立在原型上,可以彼此分享。我們只需要把共用函式定義在 prototype 上。
複製代碼 代碼如下:
var Person = function () {
//private
var welcomeMessage = 'welcome';
var fullName = '';
var firstName = '';
var lastName = "";
var createFullName = function () {
fullName = firstName + ' ' + lastName;
};
//constructor
var Person = function () { }; //will be created everytime
//public
Person.prototype = {
getFullName: function () {
createFullName();
return welcomeMessage + ' ' + fullName;
},
setFirstName: function (fName) {
firstName = fName;
},
setLastName: function (lName) {
lastName = lName;
},
ChangeMessage: function (mesg) {
welcomeMessage = mesg;
}
}
return new Person();
};
var person1 = new Person();
person1.setFirstName('Eli');
person1.setLastName('Flowers');
person1.ChangeMessage('welcome');
var message = person1.getFullName(); // welcome Eli Flowers
alert(message);
原型模式有幾個問題要正視:一是它無法存取私有變數與私有函式,因為原型上的方法與建構函式內的閉包不在同一個作用域;也正因如此,我們才需要閉包來組織程式碼,避免全局被污染。二是每次建立實例時,整段程式(包含原型的綁定)都會重跑一遍,這對部分人來說是效率問題。改善方式是只在共用函式尚未綁定時才綁一次原型,之後的實例只做檢查——雖然這麼做仍無法解決上面那個私有存取的問題,但至少省下一部分記憶體。三是私有函式同樣無法直接存取原型函式。
值得捫心自問的是:為什麼一定要私有函式與私有變數?通常是想實作封裝,確保內部資料不被意外竄改。但請記住——JavaScript 程式碼沒辦法編譯成二進位,它始終是可讀的。所以不論你有沒有真的實作私有,只要程式碼交到別人手上(團隊成員或客戶),想動手腳的人都能動。實作私有確實有一點幫助,但它擋的是「無意的誤用」,不是惡意。
另一個常見技術是約定式命名:用底線「_」作為前綴,標示某成員「請勿從外部存取」。
複製代碼 代碼如下:
(function () {
var Person = function () {
this._fullName = '';
this.welcomeMessage = '';
this.firstName = '';
this.lastName = "";
_that = this;
this._createFullName = function () {
this.ChangeMessage('Namaste');
this._fullName = this.firstName + ' ' + this.lastName;
};
}
//Shared Functions for Code optimization
Person.prototype = {
constructor: Person,
getFullName: function () {
this._createFullName();
return this.welcomeMessage + ' ' + this._fullName;
},
ChangeMessage: function (mesg) {
this.welcomeMessage = mesg;
}
}
this.Person = Person;
})();
var person1 = new Person();
person1.firstName = 'Eli';
person1.lastName = 'Flowers';
person1.ChangeMessage('Welcome');
var message = person1.getFullName(); // Namaste Eli Flowers
alert(message);
並不是說不該考慮私有。你是程式碼的設計者,最清楚怎麼管理最合適;依需求挑一種模式,或把幾種模式組合起來都可以。
無論最後選哪一種,都請記住幾個原則:把事情做少一點、不要在全域作用域製造閉包、盡量避免記憶體洩漏、把程式碼組織清楚。而這一切的前提,是對作用域、閉包與 this 的行為有足夠的理解。
平常寫 JavaScript,印象一直是「拷貝過來就能用」。近來使用 ExtJS,它的類別框架相當好用,讀完這類文章,總算把 JavaScript 中實作類別的各種方式,以及私有成員的最終極限都弄清楚了。
補充一個現代觀點:ES6 的 class 語法本質上只是建構函式加原型的語法糖,並沒有改變底層模型;而 #privateField 這類私有欄位語法才是真正在語言層級提供的私有性。理解本文這條演進脈絡,再回頭看 class 語法,會清楚很多。