所謂高品質的 JavaScript,並不只是「能跑」而已,它涵蓋一系列具體的實作要點:避開全域變數、採用單一 var 宣告、在迴圈中預先快取 length、維持可讀的排版,以及更多細節。
除了純技術層面,這份清單也包含一些看似與程式碼無關、卻深刻影響最終成果的習慣,例如撰寫 API 文件、進行同儕 code review、定期跑一遍 JSLint。這些做法累積起來,會讓你的程式碼更容易被理解與維護,而且幾個月甚至幾年後回頭重讀,你會為自己當初的自律感到慶幸。
修 bug 的成本很高,而且會隨時間推移持續攀升——尤其是當缺陷潛伏到已上線的產品裡之後。最佳的修復時機永遠是「現在」:此刻你腦中還清楚這段程式碼要解決的問題。一旦你轉去處理別的任務、把細節忘得差不多,再回來時就得重新花時間理解問題、理解程式碼。
更現實的是,在大團隊或大公司裡,發現 bug 的人往往不是修復它的人,甚至也不是原作者。因此降低「讀懂程式碼」的成本至關重要,這直接關係到營收,也關係到開發者的幸福感——畢竟我們更想投入在令人振奮的新功能上,而不是耗上好幾天考古遺留程式碼。
另一個軟體開發的殘酷事實是:讀程式碼的時間遠多於寫程式碼。專注時你可能一個下午就寫出大量程式碼,而且很快就能跑起來。但隨著專案成熟,變化會接踵而來:
於是幾小時寫完的程式碼,最終可能要花上幾週去閱讀。這就是可維護性決定專案成败的原因。可維護的程式碼具備這些特質:可讀、一致、可預測、看起來像同一個人寫的、並且已經寫成文件。
JavaScript 依靠函數來劃分作用域:宣告在函數內的變數只存在於該函數中。反之,在任何函數之外宣告、或乾脆不宣告就直接使用的變數,就成了全域變數。
每個 JavaScript 環境都有一個全域物件,在函數外使用 this 即可存取。你建立的每個全域變數都會變成這個物件的屬性。在瀏覽器中,這個全域物件還有一個別名 window:
myglobal = "hello"; // 不建議
console.log(myglobal); // "hello"
console.log(window.myglobal); // "hello"
console.log(this.myglobal); // "hello"
問題在於整頁的所有程式碼共享同一個全域命名空間。當程式的兩個部分宣告了同名但語意不同的全域變數,命名衝突幾乎無可避免。而網頁上跑著別人寫的程式碼是常態:第三方函式庫、廣告腳本、流量分析、各類小工具與按鈕……
舉例來說,某個第三方腳本定義了全域變數 result,接著你的函式也定義了 result,後者直接覆蓋前者,對方腳本立刻陣亡。因此想跟其他腳本做好鄰居,就必須盡量克制使用全域變數。
要減少全域變數,最根本的一條規則是:永遠用 var 宣告變數。JavaScript 有兩個特性讓人一不小心就製造出全域變數——變數不宣告也能用,而且未宣告的變數會自動掛成全域物件的屬性:
function sum(x, y) {
result = x + y; // 隱式全域變數,不建議
return result;
}
加上 var 就沒事了:
function sum(x, y) {
var result = x + y;
return result;
}
另一個常見陷阱是「宣告時連鎖賦值」。下面這段程式裡 a 是區域變數,b 卻是全域變數,通常並非本意:
function foo() {
var a = b = 0; // 反例
}
原因是賦值由右向左進行:先執行 b = 0,此時 b 未經宣告,表達式回傳 0,再把 0 指派給以 var 宣告的 a,等同於 var a = (b = 0);。想連鎖賦值也安全,先把變數都宣告出來:
function foo() {
var a, b;
a = b = 0; // 兩個都是區域變數
}
避免全域變數的另一個理由是可攜性。當程式碼要跑在不同宿主環境時,全域變數猶如走在薄冰上——你可能不知不覺覆蓋了原本環境裡不存在、換個環境卻是內建物件的名稱。
隱式全域變數與明確宣告的全域變數有個微妙差異:能否被 delete 刪除。用 var 建立的全域變數無法刪除,而未經 var 的隱式全域變數可以:
var global_var = 1;
global_novar = 2; // 反例
(function () {
global_fromfunc = 3; // 反例
}());
delete global_var; // false
delete global_novar; // true
delete global_fromfunc; // true
也就是說,隱式全域變數嚴格說來並不是變數,而是全域物件的屬性,屬性能被 delete,變數不能。順帶一提,在 ES5 嚴格模式下,操作未宣告的變數會直接丟出錯誤。
瀏覽器裡可以用 window 存取全域物件,但其他環境未必有這個方便的別名。若不想硬寫 window,可以用:
var global = (function () {
return this;
}());
因為是以普通函數方式呼叫(非 new 建構),this 會指向全域物件。不過這招在 ES5 嚴格模式下失效,此時可以改用「把全域 this 當參數傳進立即執行函式」的做法。
在函式頂端用一個 var 陳述式宣告所有區域變數,是相當實用的風格。它帶來幾個好處:所有區域變數集中在一處、避免在宣告前就使用變數造成的邏輯錯誤、也提醒你少用全域變數,同時程式碼量更少。
function func() {
var a = 1,
b = 2,
sum = a + b,
myobject = {},
i,
j;
// 函式主體
}
宣告時順便初始化是個好習慣:未初始化的變數值為 undefined,明確賦值可以預防邏輯錯誤,也讓讀者從初始值判斷變數用途(物件?整數?)。你也可以在宣告時就實際做點事,例如 sum = a + b,或把 DOM 查詢一起收攏:
function updateElement() {
var el = document.getElementById("result"),
style = el.style;
// 後續操作
}
你可以在函式的任何位置寫多個 var,但它們的效果等同於全部搬到函式頂端,這個行為稱為 hoisting。若在宣告之前就使用同一函式內的變數,很容易踩到邏輯陷阱:
myname = "global";
function func() {
alert(myname); // "undefined"
var myname = "local";
alert(myname); // "local"
}
func();
你可能以為第一個 alert 會顯示 "global",但實際上是 "undefined",因為 myname 已被視為函式內的區域變數,宣告被提升到頂部。等價寫法如下:
function func() {
var myname; // 等同 var myname = undefined;
alert(myname); // "undefined"
myname = "local";
alert(myname); // "local"
}
結論很清楚:想用的變數,先在函式開頭宣告好。嚴格說,引擎的處理分為「建立宣告與進入上下文」和「執行程式碼」兩個階段,hoisting 只是描述這種行為的方便說法,ECMAScript 規範裡並沒有這個名詞。
最常見的迴圈寫法如下,但它每次迭代都要重新讀取一次 length:
for (var i = 0; i < myarray.length; i++) {
// ...
}
當 myarray 不是陣列,而是 HTMLCollection 時,代價特別高。所謂 HTMLCollection 是 DOM 方法回傳的集合物件,例如:
document.getElementsByName()
document.getElementsByClassName()
document.getElementsByTagName()
document.images // 頁面上所有圖片
document.links // 所有 a 標籤
document.forms // 所有表單
document.forms[0].elements // 第一個表單中的所有欄位
這些集合是「即時」的,每次存取 length 都要重新查一次 DOM,而 DOM 操作通常不便宜。因此把長度快取起來才是正確做法:
for (var i = 0, max = myarray.length; i < max; i++) {
// ...
}
搭配單一 var 模式,還可以把 i 與 max 提到迴圈外面:
function looper() {
var i = 0,
max,
myarray = [];
for (i = 0, max = myarray.length; i < max; i++) {
// ...
}
}
這麼做風格一致,但重構時複製貼上整個迴圈會稍微麻煩,因為得確認 i 和 max 有被帶進新函式。另外,JSLint 建議用 i += 1 或 i = i + 1 取代 i++,理由是避免過度取巧的寫法。
還有兩種微調版本,好處是少一個變數,而且遞減到 0 通常比與非 0 值比較更有效率:
var i, myarray = [];
for (i = myarray.length; i--;) {
// ...
}
var myarray = [], i = myarray.length;
while (i--) {
// ...
}
for-in 應該用在非陣列物件的遍歷(枚舉)上。技術上你也可以對陣列使用 for-in,但並不建議:陣列若被擴增了自訂屬性可能導致邏輯錯誤,而且屬性列舉的順序無法保證。原則很簡單——陣列用 for,物件用 for-in。
遍歷物件時,務必用 hasOwnProperty() 過濾掉原型鏈上繼承而來的屬性:
var man = { hands: 2, legs: 2, heads: 1 };
if (typeof Object.prototype.clone === "undefined") {
Object.prototype.clone = function () {};
}
// 正確做法
for (var i in man) {
if (man.hasOwnProperty(i)) {
console.log(i, ":", man[i]);
}
}
// hands: 2 / legs: 2 / heads: 1
// 反例:未過濾,clone 也會被印出來
for (var i in man) {
console.log(i, ":", man[i]);
}
更嚴謹的寫法是直接呼叫原型上的方法,避免 man 自己重新定義了 hasOwnProperty 造成衝突:
for (var i in man) {
if (Object.prototype.hasOwnProperty.call(man, i)) {
console.log(i, ":", man[i]);
}
}
// 也可以先快取,減少屬性查找
var i, hasOwn = Object.prototype.hasOwnProperty;
for (i in man) {
if (hasOwn.call(man, i)) {
console.log(i, ":", man[i]);
}
}
嚴格來說,不用 hasOwnProperty 並不算錯誤。若你很確定物件內容與原型鏈狀態,為了少許效能可以省略;但不確定時,加上它比較保險。
擴增建構函式的 prototype 是很強大的擴充手段,但有時強到危險。往 Object()、Array()、Function() 等內建物件原型上加東西,會嚴重傷害可維護性——其他開發者會預期內建方法照原本的方式運作,而不是你私自追加的版本;而且這些屬性會在 for-in 中冒出來,造成困惑。
只有在同時滿足以下三個條件時,才值得破例:
if (typeof Object.prototype.myMethod !== "function") {
Object.prototype.myMethod = function () {
// 實作
};
}
var inspect_me = 0,
result = '';
switch (inspect_me) {
case 0:
result = "zero";
break;
case 1:
result = "one";
break;
default:
result = "unknown";
}
值得堅持的風格約定:case 與 switch 對齊、case 內的程式碼縮排、每個 case 以 break 明確結束、避免刻意貫穿(若真的需要,務必註明原因)、並以 default 收尾,確保永遠有合理結果。
JavaScript 在比較時會做隱式轉換,所以 false == 0 和 "" == 0 都會回傳 true。為了不讓讀者猜你在想什麼,比較值與型別時一律使用 === 和 !==:
var zero = 0;
if (zero === false) {
// 不會執行
}
if (zero == false) {
// 會執行
}
有人認為 == 就夠了,例如用 typeof 時已知回傳字串。但 JSLint 要求嚴格相等,這能讓程式碼更一致,也降低閱讀時的判斷負擔——讀者不必去想「這裡的 == 是刻意還是筆誤」。
請記住這句咒語:eval() 是魔鬼。它接受任意字串並當成程式碼執行。若程式碼在撰寫時就已確定,完全沒有理由用 eval;就算是執行期動態組出來的,通常也有更好的替代方案。例如存取動態屬性時,用中括號寫法就夠了:
var property = "name";
alert(eval("obj." + property)); // 反例
alert(obj[property]); // 更好
eval 也帶來安全風險,因為被執行的字串(例如來自網路的內容)可能已被竄改。處理 Ajax 回傳的 JSON 時尤其常見,正確做法是改用內建的 JSON 解析方法確保安全;若瀏覽器不支援 JSON.parse(),可以引入 JSON.org 的函式庫。
同樣要小心的是:把字串傳給 setInterval()、setTimeout() 和 Function() 建構子,大部分情況下與 eval 等價,底層仍需要評估並執行字串。
setTimeout("myFunc()", 1000); // 反例
setTimeout("myFunc(1, 2, 3)", 1000); // 反例
setTimeout(myFunc, 1000); // 更好
setTimeout(function () {
myFunc(1, 2, 3);
}, 1000);
如果你真的別無選擇,new Function() 比 eval 稍微可控一些:其中的程式碼在區域函式作用域中評估,用 var 宣告的變數不會自動變成全域變數;另一個作法是「把 eval 包進立即執行函式」。
var jsstring = "var un = 1; console.log(un);";
eval(jsstring); // 1
jsstring = "var deux = 2; console.log(deux);";
new Function(jsstring)(); // 2
jsstring = "var trois = 3; console.log(trois);";
(function () { eval(jsstring); }()); // 3
console.log(typeof un); // number ← 污染了全域
console.log(typeof deux); // "undefined"
console.log(typeof trois); // "undefined"
另一個差異是 eval 能存取並修改外層作用域的變數,Function() 只看得到全域作用域,因此更不容易污染區域變數:
(function () {
var local = 1;
eval("local = 3; console.log(local)"); // 3
console.log(local); // 3
}());
(function () {
var local = 1;
Function("console.log(typeof local);")(); // undefined
}());
parseInt() 的第二個參數(基數)經常被省略,但這是不該省的事。當字串以 0 開頭時特別容易出問題——在 ECMAScript 3 中,以 0 開頭的字串會被當成八進位處理(ES5 已修正,但為了避免歧義仍應明確指定):
var month = "06",
year = "09";
month = parseInt(month, 10);
year = parseInt(year, 10);
若省略基數,parseInt("09") 會回傳 0,因為 9 不是合法的八進位數字。替代方案是直接轉數字:
+"08" // 8
Number("08") // 8
這些通常比 parseInt 快,因為它們只是單純的轉換。但要注意:若輸入是 "08 hello" 這類混合格式,parseInt 仍能解析出數字,而上述寫法會得到 NaN。
有規範、而且全團隊都遵守,程式碼就會一致、可預測、易讀。新成員加入時只要讀一遍規範,就能快速理解既有程式碼並上手。
關於規範的爭論(縮排用 tab 還是空白?括號放同一行還是下一行?)在會議和郵件列表上層出不窮。如果你是推動規範的人,請做好面對各種強烈意見的心理準備。但請記住一件事:「有規範並穩定執行」遠比「規範的細節是什麼」重要。
沒有縮排的程式碼幾乎無法閱讀,而唯一比不縮排更糟的是「不一致的縮排」——它看起來像是遵守了規範,實際上卻埋滿驚喜。該縮排的是所有花括號內的內容:函式主體、迴圈(do、while、for、for-in)、if、switch,以及物件字面量的屬性。
即使語法允許省略,也永遠要寫大括號:
// 反例
for (var i = 0; i < 10; i += 1)
alert(i);
// 反例:後來加了第二行,它其實在迴圈外
for (var i = 0; i < 10; i += 1)
alert(i);
alert(i + " is " + (i % 2 ? "odd" : "even"));
// 正確
for (var i = 0; i < 10; i += 1) {
alert(i);
}
if (true) {
alert(1);
} else {
alert(2);
}
放在同一行或下一行,這件事向來見仁見智,但有個例外必須注意:分號自動插入機制。JavaScript 會在你省略分號時試著補上,這可能釀成意外:
// 警告:回傳值不如預期
function func() {
return
// 以下程式碼不會執行
{
name : "Batman"
}
}
// 等價於 return undefined;
所以請把左括號放在前一行語句的同一行:
function func() {
return {
name : "Batman"
};
}
分號同理:即使引擎會自動補上,也應該一律明確寫出。這讓程式碼更嚴謹,也能避開上面那類歧義。
寫英文時我們在逗號和句號後留空格,JavaScript 也一樣:在「分隔項目的逗號」和「結束陳述式的分號」後加空格,可讀性會明顯提升。適合放空白的地方包括:
for (var i = 0; i < 10; i += 1)for (var i = 0, max = 10; i < max; i += 1)var a = [1, 2, 3];var o = {a: 1, b: 2};myFunc(a, b, c)function myFunc() {}var myFunc = function () {};另外,所有運算子與運算元之間都應該留空格,包含 + - * = < > <= >= === !== && || += 等:
// 良好範例
var d = 0,
a = b + 1;
if (a && b && c) {
d = a % c;
a += d;
}
// 反例
var d = 0,
a = b + 1;
if (a&&b&&c) {
d=a % c;
a+= d;
}
花括號前後也建議留白:函式、if-else、迴圈、物件字面量的左括號之前;else 或 while 之前的右括號之後。空白會讓檔案變大,但壓縮後影響可忽略。
還有一個常被忽略的面向:垂直空白。用空行分隔程式碼區塊,就像文章分段一樣,能大幅提升可讀性。
JavaScript 沒有 class,但有搭配 new 使用的建構函式。用大寫命名建構函式、小寫命名一般函式,能讓讀者一眼分辨:
function MyConstructor() {...}
function myFunction() {...}
名稱含多個單字時,請統一風格。常見做法是駝峰命名:建構函式用大駝峰(MyConstructor()),函式與方法用小駝峰(myFunction()、calculateArea()、getFirstName())。變數若不是函式,通常用小駝峰,也有人偏好全小寫加底線(first_name、favorite_bands),這麼做的好處是能直觀區分函式與其他標識。ECMAScript 本身的屬性與方法採用駝峰式。
JavaScript 沒有宣告常數的語法,因此慣例上會用全大寫命名在生命週期內不變的值:
var PI = 3.14,
MAX_WIDTH = 800;
另一個全大寫慣例是全域變數。這麼做一方面強化了「少用全域變數」的心理約束,另一方面讓它們在程式碼中格外顯眼。
模擬私有成員的方式則是在名稱前加一個底線:
var person = {
getName: function () {
return this._getFirst() + ' ' + this._getLast();
},
_getFirst: function () {
// ...
},
_getLast: function () {
// ...
}
};
這裡 getName() 代表穩定、公開的 API,而 _getFirst()、_getLast() 藉由底線前綴警告使用者:這些方法在下一版可能改變,請勿直接依賴。其他常見變體包括:用後置底線表示私有(name_、getElements_())、單底線表示 protected、雙底線表示 private;而 Firefox 部分非標準內建屬性使用前後雙底線,如 __proto__ 與 __parent__。
一定要寫註解,即使只有你會讀它。鑽進問題時你很清楚程式碼在做什麼,但一週後回頭看,往往要耗掉不少腦細胞。註解不必走極端(不需要替每個變數、每一行都寫),但所有函式、其參數與回傳值,以及任何不尋常的技術手法,都應該記錄下來。
目標是讓未來的讀者只看註解和函式名稱就能理解全貌。例如某段五六行的程式在執行特定任務,只要註明「目的」與「為什麼在這裡」,讀者就能直接跳過細節。有些部分(例如複雜的正則運算式)註解甚至比程式碼還長,這完全沒問題。
最關鍵、也最難堅持的習慣是:保持註解同步更新。過時的註解比沒有註解更具誤導性。
本文整理自 Stoyan Stefanov 的相關著作觀點,他是 Yahoo! 前端開發者,也是多本 O'Reilly 書籍的作者與技術審閱者,同時是 smush.it 圖片優化工具的作者與 YSlow 2.0 的架構設計師。