永遠使用 var 宣告變數。若省略 var,變數會被隱式宣告為全域變數,導致難以控制,也讓所處定義域變得模糊(可能是 Document 或 Window,也可能不小心進入區域定義域)。此外,啟用嚴格模式後,手誤打錯變數名時能透過錯誤訊息快速定位問題。
變數名建議使用駝峰法(camelCase);全域變數與常數(如 PI)使用全大寫(UPPERCASE);函式方面,建構函式首字母大寫,非建構函式首字母小寫。變數名不要以 $ 作為起始標記,以免與許多 JavaScript 函式庫衝突。
總是把程式碼包進 IIFE(Immediately-Invoked Function Expression),以建立獨立隔絕的定義域。這麼做既能防止全域命名空間被污染,也能確保程式碼不會輕易被其他程式碼(第三方函式庫、window 參照、被覆寫的 undefined 等)改動。
// 不推薦
var x = 10, y = 100;
// 在全域宣告變數會造成全域污染,所有變數都會掛到 window 上
console.log(window.x + ' ' + window.y);
// 推薦
(function(log, w, undefined){
'use strict';
var x = 10, y = 100;
// 輸出 true true
log((w.x === undefined) + ' ' + (w.y === undefined));
}(window.console.log, window));
任何時候需要一個新的封閉定義域,就用 IIFE。它不僅避免干擾,還能讓記憶體在執行完後立即釋放。所有腳本檔都建議從 IIFE 開始。
執行用的括號應該寫在外層括號內。寫在內或外都有效,但寫在內讓整個表達式看起來更完整,因此推薦這麼做。
// 不推薦
(function(){})();
// 推薦
(function(){}());
// 建議格式
(function(){
'use strict';
// Code goes here
}());
若要引用全域變數或外層 IIFE 的變數,用傳參方式帶入:
(function($, w, d){
'use strict';
$(function() {
w.alert(d.querySelectorAll('div').length);
});
}(jQuery, window, document));
ECMAScript 5 的嚴格模式可在整個腳本或個別方法內啟用,它會在不同情境下做更嚴格的錯誤檢查,確保程式碼更健壯、運行更快,並阻止使用未來可能成為保留字的關鍵字。
建議在獨立的 IIFE 中啟用,而不是寫在腳本第一行——那樣會讓所有腳本都進入嚴格模式,可能引發第三方函式庫的問題。
// 不推薦
'use strict';
(function(){
// Your code starts here
}());
// 推薦
(function(){
'use strict';
// Your code starts here
}());
JavaScript 會把變數與函式定義自動提升到執行之前。它只有 function 級定義域,沒有塊級定義域,因此在函式內某個語句或迴圈中宣告的變數,作用範圍會擴及整個函式。
原始程式碼:
(function(log){
'use strict';
var a = 10;
for(var i = 0; i < a; i++) {
var b = i * i;
log(b);
}
if(a === 10) {
var f = function() { log(a); };
f();
}
function x() { log('Mr. X!'); }
x();
}(window.console.log));
被 JS 提升後:
(function(log){
'use strict';
// 閉包內所有變數都會被提升到函式頂部
var a, i, b, f;
// 閉包內所有函式宣告也會被提升到頂部
function x() { log('Mr. X!'); }
a = 10;
for(i = 0; i < a; i++) {
b = i * i;
log(b);
}
if(a === 10) {
// 函式指派的結果只會產生被提升的變數,函式體不會被提升
// 只有真正的函式宣告,才會連同函式體一起提升
f = function() { log(a); };
f();
}
x();
}(window.console.log));
理解這套機制後,下面這段看似混亂的程式碼其實完全合法:
(function(log){
'use strict';
var a = 10;
i = 5;
x();
for(var i; i < a; i++) {
log(b);
var b = i * i;
}
if(a === 10) {
f = function() { log(a); };
f();
var f;
}
function x() { log('Mr. X!'); }
}(window.console.log));
正因為結果容易出乎意料,養成良好的宣告習慣才能把風險降到最低。
為避免自動提升造成誤解,我們應該手動把變數與函式定義放在函式開頭。只用一個 var 關鍵字,多個變數以逗號隔開。
// 不推薦
(function(log){
'use strict';
var a = 10;
var b = 10;
for(var i = 0; i < 10; i++) {
var c = a * b * i;
}
function f() { }
var d = 100;
var x = function() { return d * d; };
log(x());
}(window.console.log));
// 推薦
(function(log){
'use strict';
var a = 10, b = 10, i, c, d, x;
function f() { }
for(i = 0; i < 10; i++) {
c = a * b * i;
}
d = 100;
x = function() { return d * d; };
log(x());
}(window.console.log));
賦值盡量寫在宣告處:
// 不推薦 var a, b, c; a = 10; b = 10; c = 100; // 推薦 var a = 10, b = 10, c = 100;
一律使用 ===,避免 JavaScript 的強制型別轉換帶來困擾。使用 === 時,比較雙方必須同型別才可能相等。只寫 == 的話,轉換規則會讓結果變得難以追蹤:
(function(log){
'use strict';
log('0' == 0); // true
log("" == false); // true
log('1' == true); // true
log(null == undefined); // true
var x = { valueOf: function() { return 'X'; } };
log(x == 'X'); // true,因為觸發了 valueOf
}(window.console.log));
在 if 條件中使用變數或表達式時會做真假判斷。if(a == true) 與 if(a) 並不相同,後者就是真假判斷,會依下列規則轉為布林值:false、0、undefined、null、NaN、""(空字串)一律為假。
(function(log){
'use strict';
function logTruthyFalsy(expr) {
if(expr) { log('truthy'); } else { log('falsy'); }
}
logTruthyFalsy(true); // truthy
logTruthyFalsy(1); // truthy
logTruthyFalsy({}); // truthy
logTruthyFalsy([]); // truthy
logTruthyFalsy('0'); // truthy
logTruthyFalsy(false); // falsy
logTruthyFalsy(0); // falsy
logTruthyFalsy(undefined); // falsy
logTruthyFalsy(null); // falsy
logTruthyFalsy(NaN); // falsy
logTruthyFalsy(""); // falsy
}(window.console.log));
邏輯運算子 || 與 && 也可用來回傳布林值。若運算元不是布林,每個表達式會由左而右做真假判斷,最終總有一個被回傳,這在賦值時能大幅精簡程式碼。
// 不推薦
if(!x) {
if(!y) { x = 1; } else { x = y; }
}
// 推薦
x = x || y || 1;
這個技巧常用於設定方法的預設參數:
(function(log){
'use strict';
function multiply(a, b) {
a = a || 1;
b = b || 1;
log('Result ' + a * b);
}
multiply(); // Result 1
multiply(10); // Result 10
multiply(3, NaN); // Result 3
multiply(9, 5); // Result 45
}(window.console.log));
永遠補上分號。隱式的語句串接會引發難以察覺的問題:
// 1.
MyClass.prototype.myMethod = function() { return 42; } // 這裡沒有分號
(function() {
// 用函式包起來建立區域定義域
})();
var x = { 'i': 1, 'j': 2 } // 這裡沒有分號
// 2.
[ffVersion, ieVersion][isIE]();
var THINGS_TO_EAT = [apples, oysters, sprayOnCheese] // 這裡沒有分號
// 3.
-1 == resultOfOperation() || die();
會發生什麼事?
JavaScript 報錯——回傳 42 的那個函式被下一段當作參數呼叫,接著數字 42 也被「呼叫」而抛出錯誤。第二段則可能出現「undefined 中沒有該屬性」的錯誤,因為實際呼叫形式是 x[ffVersion, ieVersion][isIE]()。第三段中 die() 永遠會被執行,因為陣列減 1 得到 NaN,而 NaN 不等於任何值。
原因?
JavaScript 語句必須以分號結束,換行並不會終結語句。以上每段範例中,函式宣告、物件或陣列都被併入了同一句話。閉合的圓括號不代表語句結束——除非下一個 token 是中綴運算子或圓括號運算子,否則 JavaScript 不會終結語句。
分號與函式的區別
分號用在表達式結尾,而非函式宣告結尾:
var foo = function() { return true; }; // 需要分號
function foo() { return true; } // 不需要分號
嵌套函式非常有用,例如在持續建立並隱藏輔助函式的場景中,可以自由使用。
切勿在語句塊內宣告函式——在 ECMAScript 5 嚴格模式下這是不合法的。函式宣告應放在定義域頂層;若確有必要,改寫成函式表達式賦值給變數。
// 不推薦
if (x) { function foo() {} }
// 推薦
if (x) { var foo = function() {}; }
做大型開發時你很難完全避免異常。若沒有自訂異常機制,從有回傳值的函式中回傳錯誤訊息會相當棘手也不優雅。常見的陋習包括傳入一個參照物件來接收錯誤,或總是回傳一個可能含錯誤物件的清單。在複雜環境中,建議拋出物件而非僅拋出字串:
if(name === undefined) {
throw {
name: 'System Error',
message: 'A name should always be specified!'
}
}
為兼顧擴充性與相容性,應優先採用標準特性而非非標準寫法。例如用 string.charAt(3) 而非 string[3];用標準 DOM 方法取得元素參照,而非特定應用的快捷方法。
若只需簡單繼承,可用以下模式;若預期會遇到複雜繼承結構,建議引入專門的繼承庫。
(function(log){
'use strict';
// 建構函式
function Apple(name) {
this.name = name;
}
// 定義方法
Apple.prototype.eat = function() {
log('Eating ' + this.name);
};
// 子類建構函式
function GrannySmithApple() {
// 呼叫父類建構函式
Apple.prototype.constructor.call(this, 'Granny Smith');
}
// 以 Object.create 建立原型副本並指定為父類原型
GrannySmithApple.prototype = Object.create(Apple.prototype);
// 修正 constructor 指向,否則會指回 Apple
GrannySmithApple.prototype.constructor = GrannySmithApple;
// 覆寫並呼叫父類方法
GrannySmithApple.prototype.eat = function() {
// 記得用 call(this) 套用到當前物件
Apple.prototype.eat.call(this);
log('Poor Grany Smith');
};
var apple = new Apple('Test Apple');
var grannyApple = new GrannySmithApple();
log(apple.name); // Test Apple
log(grannyApple.name); // Granny Smith
log(apple instanceof Apple); // true
log(apple instanceof GrannySmithApple); // false
log(grannyApple instanceof Apple); // true
log(grannyApple instanceof GrannySmithApple); // true
grannyApple.eat(); // Eating Granny Smith / Poor Grany Smith
}(window.console.log));
閉包的建立可能是 JS 最有用也最容易被忽略的能力,理解它的運作方式對寫出可靠的非同步程式碼至關重要。
在迴圈中加入函式很容易形成閉包而帶來隱患,以下就是典型的陷阱:
// 不推薦
(function(log, w){
'use strict';
var numbers = [1, 2, 3], i;
for(i = 0; i < numbers.length; i++) {
w.setTimeout(function() {
// 執行時 i 已變成 3,因此會 alert 三次 "Index 3 with number undefined"
w.alert('Index ' + i + ' with number ' + numbers[i]);
}, 0);
}
}(window.console.log, window));
用 IIFE 建立獨立閉包雖然能解決問題,但仍有兩個函式被建立,違反了「不在迴圈中建立函式」的原則:
// 不推薦
(function(log, w){
'use strict';
var numbers = [1, 2, 3], i;
for(i = 0; i < numbers.length; i++) {
(function(index, number){
w.setTimeout(function() {
w.alert('Index ' + index + ' with number ' + number);
}, 0);
}(i, numbers[i]));
}
}(window.console.log, window));
把產生閉包的動作抽到迴圈外,雖然已解決問題,寫法卻顯得繁瑣:
// 不完全推薦
(function(log, w){
'use strict';
var numbers = [1, 2, 3], i;
function alertIndexWithNumber(index, number) {
return function() {
w.alert('Index ' + index + ' with number ' + number);
};
}
for(i = 0; i < numbers.length; i++) {
w.setTimeout(alertIndexWithNumber(i, numbers[i]), 0);
}
}(window.console.log, window));
改用函式式寫法(如 forEach)才是最好的解法,每次迭代自然對應一次閉包,語意清楚且可預期:
// 推薦
(function(log, w){
'use strict';
var numbers = [1, 2, 3];
numbers.forEach(function(number, index) {
w.setTimeout(function() {
w.alert('Index ' + index + ' with number ' + number);
}, 0);
});
}(window.console.log, window));
eval() 既混淆語境又存在風險,永遠有更好、更清晰、更安全的替代方案,請盡量不要使用這個「魔鬼函式」。
只在物件建構器、方法,以及設定好的閉包中使用 this。它的語意容易誤導:時而指向全域物件,時而指向呼叫者的定義域(如在 eval 中),時而指向 DOM 樹中的節點(事件綁定到 HTML 屬性時),時而指向新建的物件(建構式中),被 call() 與 apply() 呼叫時又指向另一個物件。
正因為容易出錯,請把它的使用限制在:建構函式中、物件方法中(含由此建立的閉包內)。
函式式編程能簡化程式碼並降低維護成本,因為它容易複用、適當解耦且依賴更少。以陣列求和為例:
// 不推薦
(function(log){
'use strict';
var arr = [10, 3, 7, 9, 100, 20], sum = 0, i;
for(i = 0; i < arr.length; i++) {
sum += arr[i];
}
log('The sum of array ' + arr + ' is: ' + sum)
}(window.console.log));
// 推薦
(function(log){
'use strict';
var arr = [10, 3, 7, 9, 100, 20];
var sum = arr.reduce(function(prevValue, currentValue) {
return prevValue + currentValue;
}, 0);
log('The sum of array ' + arr + ' is: ' + sum);
}(window.console.log));
又如依規則篩選陣列:
// 不推薦
(function(log){
'use strict';
var numbers = [11, 3, 7, 9, 100, 20, 14, 10],
numbersGreaterTen = [], i;
for(i = 0; i < numbers.length; i++) {
if(numbers[i] > 10) {
numbersGreaterTen.push(numbers[i]);
}
}
log('From the list of numbers ' + numbers
+ ' only ' + numbersGreaterTen + ' are greater than ten');
}(window.console.log));
// 推薦
(function(log){
'use strict';
var numbers = [11, 3, 7, 9, 100, 20, 14, 10];
var numbersGreaterTen = numbers.filter(function(element) {
return element > 10;
});
log('From the list of numbers ' + numbers
+ ' only ' + numbersGreaterTen + ' are greater than ten');
}(window.console.log));
例外情況:當程式碼效能比維護性更關鍵時,應選擇效能最佳的解法,例如用簡單的 for 迴圈取代 forEach。
陣列與物件的迭代:用 ES5 的迭代方法處理陣列,需要在特定條件下中斷時可用 every。
(function(log){
'use strict';
[1, 2, 3, 4, 5].every(function(element, index, arr) {
log(element + ' at index ' + index + ' in array ' + arr);
if(index !== 5) { return true; }
});
var obj = { a: 'A', b: 'B', 'c-d-e': 'CDE' };
Object.keys(obj).forEach(function(element, index, arr) {
log('Key ' + element + ' has value ' + obj[element]);
});
}(window.console.log));
不要使用 switch:switch 在各語言中都是較難控制的語句,建議用 if/else 取代。
用字面量取代建構器。陣列建構器特別容易在參數上出錯:
// 不推薦 var a1 = new Array(x1, x2, x3); // 長度 3 var a2 = new Array(x1, x2); // 長度 2 var a3 = new Array(x1); // 若 x1 是自然數,長度為 x1;若非自然數則抛出異常;否則視為單一元素 var a4 = new Array(); // 長度 0
也就是說,把原本兩個參數的呼叫改成一個,陣列長度就可能出現意料之外的變化。因此請一律使用可讀性更高的字面量:
// 推薦 var a = [x1, x2, x3]; var a2 = [x1, x2]; var a3 = [x1]; var a4 = [];
物件建構器沒有類似問題,但為了可讀性與一致性,同樣建議使用字面量:
// 不推薦
var o = new Object();
var o2 = new Object();
o2.a = 0;
o2.b = 1;
o2.c = 2;
o2['strange key'] = 3;
// 推薦
var o = {};
var o2 = { a: 0, b: 1, c: 2, 'strange key': 3 };
修改 Object.prototype、Array.prototype 這類內建物件是被嚴格禁止的。修改 Function.prototype 等危害雖小,但仍會造成難以除錯的問題,同樣應避免。
自訂 toString() 可以控制物件的字串化行為,但必須確保它永遠成功且無副作用。若 toString() 內呼叫了帶有斷言的方法,斷言失敗時可能又需要輸出所屬物件的名稱,於是再次呼叫 toString(),容易引發嚴重問題。
只在語法與語意真正需要時才謹慎使用圓括號。不要用在單元運算子(delete、typeof、void)上,也不要放在 return、throw、case、new 等關鍵字之後。
統一使用單引號,不使用雙引號。這在組出 HTML 字串時尤其方便:
var msg = 'This is some HTML <div class="makes-sense"></div>';
用三元運算子處理簡單的賦值或回傳,避免用在複雜情境——沒人願意用十行三元運算繞暈自己。
// 不推薦
if(x === 10) {
return 'valid';
} else {
return 'invalid';
}
// 推薦
return x === 10 ? 'valid' : 'invalid';
註 1:作者指的是採用嚴謹的語句寫法,從根本上杜絕因缺少分號引起的程式碼歧義。
註 2:中綴運算子,指像 x + y 中的 +。
註 3:斷言一般指測試時的假設,通常是布林表達式;為真則程式續行,為假則程式終止。