寫 JavaScript 寫久了會發現,真正拉開代碼品質差距的往往不是語法熟不熟,而是「你把東西放在哪裡、怎麼組織」。本系列要談的九種對象創建模式,本質上都是在回答這個問題。上篇先處理五個基礎但高頻的模式。
全局變量是 JavaScript 裡最廉價也最危險的資源。層層嵌套的對象定義如果全靠手寫,很快就會變成這樣:
var app = app || {};
app.moduleA = app.moduleA || {};
app.moduleA.subModule = app.moduleA.subModule || {};
app.moduleA.subModule.MethodA = function () {
console.log("print A");
};
app.moduleA.subModule.MethodB = function () {
console.log("print B");
};
層級一深,這種「|| {}」的守門動作就要重複很多次,可讀性極差。命名空間模式就是把這件事收斂到一個函數裡。
先聲明根對象,三種寫法安全性遞增:
// 不安全:可能直接覆蓋已有的 MYAPP
var MYAPP = {};
// 較安全
if (typeof MYAPP === "undefined") {
var MYAPP = {};
}
// 最簡潔,也是推薦寫法
var MYAPP = MYAPP || {};
然後實作一個通用的命名空間分配器:
MYAPP.namespace = function (ns_string) {
var parts = ns_string.split('.'),
parent = MYAPP,
i;
// 開頭寫了 MYAPP 也沒關係,自動忽略
if (parts[0] === "MYAPP") {
parts = parts.slice(1);
}
for (i = 0; i < parts.length; i += 1) {
// 這一段還不存在就補一個空對象
if (typeof parent[parts[i]] === "undefined") {
parent[parts[i]] = {};
}
parent = parent[parts[i]];
}
return parent;
};
使用起來非常乾淨,而且回傳值是那一層命名空間本身,可以直接拿去掛方法:
var module2 = MYAPP.namespace('MYAPP.modules.module2');
console.log(module2 === MYAPP.modules.module2); // true
MYAPP.namespace('modules.module51'); // 可省略 MYAPP 前綴
MYAPP.namespace('once.upon.a.time.there.was.this.long.name'); // 多深都不怕
模塊或函數若要引用第三方庫,最好在函數開頭就把依賴撈成局部變量。這麼做有兩個好處:一是後續代碼裡不必反覆寫長長的命名空間路徑,二是將來換庫時只需要改動這一行。
var myFunction = function () {
// 依賴集中宣告在頂部
var event = YAHOO.util.Event,
dom = YAHOO.util.dom;
// 以下就可以直接用 event、dom 這兩個局部變量
};
這個習慣同時也是性能優化:局部變量的查找鏈比全局變量短,在熱路徑上累積起來的差異相當可觀。
JavaScript 語言本身沒有 private 關鍵字,但我們可以用作用域鏈與閉包把變量藏起來,只透過授權方法對外開放。
function Gadget() {
// 私有成員,外部無法直接觸及
var name = 'iPod';
// 公有方法,形成閉包
this.getName = function () {
return name;
};
}
var toy = new Gadget();
console.log(toy.name); // undefined,name 是私有的
console.log(toy.getName()); // "iPod",只能透過授權方法讀取
另一種常見寫法是用立即執行函數創建私有作用域,再把公有部分掛到外部變量上:
var myobj;
(function () {
// 自由變量,藏在閉包裡
var name = "my, oh my";
// 注意這裡沒有 var,是要暴露到外面的公有部分
myobj = {
getName: function () {
return name;
}
};
}());
這個模式同樣為了隱藏私有實現,和 Module 模式思路接近,但風格不同:不是在最後 return 一個對象,而是先在外部宣告變量,再由內部為它賦值。差別在於私有函數可以在同一個閉包內被其他私有函數直接呼叫,而暴露出去的形式則由最後那次賦值決定,頗有一種「揭示」的意味,因此得名。
var myarray;
(function () {
var astr = "[object Array]",
toString = Object.prototype.toString;
function isArray(a) {
return toString.call(a) === astr;
}
function indexOf(haystack, needle) {
var i = 0,
max = haystack.length;
for (; i < max; i += 1) {
if (haystack[i] === needle) {
return i;
}
}
return -1;
}
// 一次賦值,把所有實現細節都收進閉包
myarray = {
isArray: isArray,
indexOf: indexOf,
inArray: indexOf // 同一個私有函數,換個名字再暴露一次
};
}());
測試時會發現一個有趣的性質:即使外部把 indexOf 設為 null,inArray 依然照常運作,因為它們指向的是同一個閉包內的私有函數引用,彼此獨立於對象上的屬性。
console.log(myarray.isArray([1, 2])); // true
console.log(myarray.isArray({ 0: 1 })); // false
console.log(myarray.indexOf(["a", "b", "z"], "z")); // 2
myarray.indexOf = null;
console.log(myarray.inArray(["a", "b", "z"], "z")); // 仍然是 2
鏈式調用的目的很單純:讓連續的方法呼叫寫成一行,可讀性大幅提升。實作原理也單純得令人愉悅——每個方法做完自己的事,把 this 原樣回傳即可。
var obj = {
value: 1,
increment: function () {
this.value += 1;
return this;
},
add: function (v) {
this.value += v;
return this;
},
shout: function () {
console.log(this.value);
}
};
// 鏈式呼叫
obj.increment().add(3).shout(); // 5
// 當然也可以一朵一朵拆開呼叫
obj.increment();
obj.add(3);
obj.shout();
jQuery 的 .addClass().css().show() 就是這個模式最成功的商業案例。需要提醒的是,鏈式風格會讓中斷點調試變得稍微棘手,而且一旦某個方法回傳了別的值,整條鏈就斷了,所以團隊內部的約定要一致。
這五個模式解決的是最基礎的組織問題:命名空間管住全局污染,依賴聲明讓替換成本變低,閉包帶來信息隱藏,Revelation 模式在隱藏之餘保留了靈活的暴露策略,鏈式則改善了調用體驗。下篇會繼續談函數語法糖、對象常量、沙盒與靜態成員。