一、用全域變數保存實例
最直白的做法:
function Person(){
this.createTime = new Date();
}
var instance = new Person();
function getInstance(){
return instance;
}
腳本載入時就建立物件,之後每次取用同一個。問題是若從頭到尾都沒人用,這個物件就白建了。可以改成延遲建立:
var instance;
function getInstance(){
if(!instance){
instance = new Person();
}
return instance;
}
但 instance 是全域變數,在多人協作或長期維護的專案中,很難保證它不會被其他程式碼改掉。用閉包把它包起來就能解決。
二、用閉包封裝
var getInstance = (function(){
var instance;
return function(){
if(!instance){
instance = new Person();
}
return instance;
};
})();
這樣 instance 被鎖在閉包裡,外部動不到。但新問題來了:如果使用者直接 new Person(),還是會得到無限多個物件,而 JavaScript 不像 Java 能把建構子設為私有。
三、在建構子的靜態屬性上快取
function Person(){
// 若已快取,直接回傳
if(typeof Person.instance === 'object'){
return Person.instance;
}
this.createTime = new Date();
Person.instance = this;
return this;
}
第一次 new 時條件為 false,正常初始化並存進靜態屬性;第二次之後條件成立,直接回傳快取值,後面的初始化不會執行。缺點和第一種一樣:Person.instance 是公開屬性,仍可能被竄改。
四、重寫建構函式
function Person(){
var instance = this;
this.createTime = new Date();
// 重寫建構函式
Person = function(){
return instance;
};
}
第一次呼叫時先快取實例再重寫自己,之後無論 new 幾次,都只會走到新的函式並回傳同一個 instance。看起來沒問題,但實測會發現原型相關的行為不如預期:
Person.prototype.prop1 = true; var p1 = new Person(); // 此時 Person 已被重寫 Person.prototype.prop2 = true; // 加在新函式的原型上 var p2 = new Person(); console.log(p1.prop1); // true console.log(p2.prop1); // true console.log(p1.prop2); // undefined console.log(p2.prop2); // undefined console.log(p1.constructor === Person); // false console.log(p2.constructor === Person); // false
原因在于:prop1 加在原始建構子的原型上,而 new Person() 之後 Person 已被替換,prop2 因此掛在新函式的原型上。由於 p1 與 p2 其實是同一個物件(原始建構子所建),兩者都只有 prop1。同理,constructor 指向的仍是原始函式,而此時的 Person 已非原物。
修正方式是把原型與 constructor 一併搬移:
function Person(){
var instance = this;
// 重寫建構函式
Person = function(){
return instance;
};
// 保留原型屬性
Person.prototype = this;
// 建立實例
instance = new Person();
// 重設 constructor 指向
instance.constructor = Person;
// 其他初始化
instance.createTime = new Date();
return instance;
}
改完之後再跑前面的測試,結果就全部符合預期了。
五、惰性單例
在大型專案中,那些「建立成本高但很少用到」的元件很適合包成惰性單例,只在第一次被請求時才真正建立:
MyNamespace.Singleton = (function() {
var uniqueInstance;
function constructor() {
// 正常的單例內容
var privateAttribute1 = false;
var privateAttribute2 = [1, 2, 3];
function privateMethod1() { /* ... */ }
function privateMethod2(args) { /* ... */ }
return {
publicAttribute1: true,
publicAttribute2: 10,
publicMethod1: function() { /* ... */ },
publicMethod2: function(args) { /* ... */ }
};
}
return {
getInstance: function() {
if(!uniqueInstance){
uniqueInstance = constructor();
}
return uniqueInstance;
}
};
})();
六、分支單例
針對不同環境提供不同實作時,可以用分支型單例在載入階段就決定採用哪一種。以 XHR 封裝為例:
var SimpleXhrFactory = (function() {
var standard = {
createXhrObject: function(){ return new XMLHttpRequest(); }
};
var activeXNew = {
createXhrObject: function(){ return new ActiveXObject('Msxml2.XMLHTTP'); }
};
var activeXOld = {
createXhrObject: function(){ return new ActiveXObject('Microsoft.XMLHTTP'); }
};
// 逐一嘗試,回傳第一個不會丟錯的實作
var testObject;
try {
testObject = standard.createXhrObject();
return standard;
} catch(e) {
try {
testObject = activeXNew.createXhrObject();
return activeXNew;
} catch(e) {
try {
testObject = activeXOld.createXhrObject();
return activeXOld;
} catch(e) {
throw new Error('No XHR object found in this environment.');
}
}
}
})();
這裡有個實務上的提醒:分支單例的判斷只做一次,好處是執行期沒有額外分支判斷的開銷;代價是環境能力若之後改變(例如執行期才注入 polyfill),這個決定不會重來。多數情況下這正是我們想要的效果。