JavaScript 是全世界使用最廣泛的語言之一,但它同時也有相當古怪的一面。開發者在用它寫程式的過程中,難免會遇到一些令人哭笑不得的「特性」。即使是經驗豐富的老手,看到下面這些例子大概也會心一笑。
== 在比較時會先做型別強制轉換,因此它能比較兩個型別不同的值——在比較之前,它會先設法把兩邊轉成同一型別:
"1" == 1 // true
這往往會誤導人,而且大多數時候我們並不需要這種行為。與其依賴隱含轉換,不如明確地先轉型再比較:
Number("1") === 1; // true
更好的做法是確保放在前面的運算元本來就是你要的型別。
更麻煩的是,== 會破壞遞移律,這點相當危險:
"" == 0 // true,空字串被轉成數字 0
0 == "0" // true,數字 0 被轉成字串 "0"
"" == "0" // false,兩邊都是字串,不進行轉換
若改用 ===,上面三個比較全部會是 false。
若省略第二個參數,基數依下列規則決定:
0x 開頭則為 16。0 開頭會被視為 8。常見的錯誤是讓使用者輸入以 0 開頭的數字,結果被當成八進位處理:
parseInt("8"); // 8
parseInt("08"); // 舊引擎為 0,ES5 之後為 8
因此實務上多半會明確指定基數:
parseInt("8", 10); // 8
parseInt("08", 10); // 8
補充一點:ECMAScript 5 已不再假設前導 0 代表八進位,而省略第二個參數也會引起 lint 工具的警告。
replace() 預設只替換第一個符合項,無論你期待的是不是全部:
"bob".replace("b", "x"); // "xob"
"bob".replace(/b/, "x"); // "xob",即使用了正則
要換掉所有符合項,得加上全域修飾符:
"bob".replace(/b/g, "x"); // "xox"
"bob".replace(new RegExp("b", "g"), "x"); // "xox"
PHP 用 . 做字串串接,JavaScript 不是如此——當運算元中有字串時,a + b 通常就是串接。想確保做數字加法,得先轉型:
1 + document.getElementById("inputElem").value; // 串接
1 + Number(document.getElementById("inputElem").value); // 相加
要注意的是,減法會嘗試把運算元轉成數字:
"3" - "1"; // 2
而「數字加空字串」雖然是常見的轉字串技巧,但可讀性不佳,建議直接用 String(3)。
typeof 回傳的是基本型別的類型名稱。陣列其實不是基本型別,因此:
typeof {} === "object" // true
typeof "" === "string" // true
typeof [] === "array" // false,實際回傳 "object"
另外,typeof null 會回傳 "object",這是語言設計早期留下的著名怪異行為。
instanceof 用來判斷物件是否由某個建構函式產生。若使用字面語法建立內建型別,結果可能不如預期:
"hello" instanceof String; // false
new String("hello") instanceof String; // true
但對陣列來說,instanceof 反而能正常工作:
["item1", "item2"] instanceof Array; // true
new Array("item1", "item2") instanceof Array; // true
實務上的結論是:測試 Boolean、String、Number、Function 時用 typeof,其他型別用 instanceof。
函式中的 arguments 以類陣列形式傳入,有 length 屬性,索引從 0 開始,但它並不是 Array。可以這樣轉成真陣列:
var args = Array.prototype.slice.call(arguments, 0);
由 getElementsByTagName 回傳的 NodeList 也適用同樣的手法。
eval 會把字串當成 JavaScript 程式碼執行,一般並不建議使用。原因有三:其一,速度很慢——腳本載入時已被編譯成原生碼,而每次執行到 eval,編譯流程就得重新跑一遍;其二,寫法醜陋且容易被濫用;其三,eval 中的程式碼會在當前作用域執行,因此能修改區域變數,甚至在你的作用域裡塞進意料之外的東西。
JSON 轉換是常見需求,過去常寫成 var obj = eval(jsonText);。如今幾乎所有瀏覽器都支援原生 JSON 物件,改用 JSON.parse(jsonText) 更安全,反向轉換則用 JSON.stringify()。
另外,setTimeout 與 setInterval 的第一個參數可以傳字串作為函式主體,但同樣不建議,直接傳函式才是正解。Function 建構式與 eval 類似,差別只在於它是在全域作用域中執行。
with 提供存取物件屬性的簡寫方式,但是否該用始終有爭議。它的問題在於可讀性:
with (obj) {
bob = "mmm";
eric = 123;
}
看到這段程式,你無法立刻判斷究竟發生什麼事。你剛剛改的是區域變數 bob,還是設定了 obj.bob?如果 obj.bob 已存在,它會被重設為 "mmm";否則可能改到外層的 bob,再不然就是新增了一個全域變數。相比之下,寫成下面這樣意思清楚得多:
obj.bob = "mmm";
obj.eric = 123;
ECMAScript 5 的嚴格模式已經不允許使用 with。
JavaScript 有 Object、Array、Boolean、Number、String、Function 等型別,各自都有字面語法,因此不需要顯式建構:
var a = new Object(); a.greet = "hello";
var a = { greet: "hello" };
var b = new Boolean(true);
var b = true;
var c = new Array("one", "two");
var c = ["one", "two"];
var d = new String("hello");
var d = "hello";
var e = new Function("greeting", "alert(greeting);");
var e = function (greeting) { alert(greeting); };
更關鍵的是,用 new 建構這些型別時,你得到的是一個型別為 Object、但繼承自該型別原型的物件:
typeof new Number(123); // "object"
typeof Number(123); // "number"
typeof 123; // "number"
為了避免混淆,一律使用字面語法。
如果你自訂了建構函式卻漏掉 new,下場會很尷尬:
var Car = function (colour) {
this.colour = colour;
};
var aCar = new Car("blue");
console.log(aCar.colour); // "blue"
var bCar = Car("blue");
console.log(bCar.colour); // undefined
console.log(window.colour); // "blue",不小心寫進了全域
用 new 呼叫函式時,會先建立一個新物件、在新的上下文中執行函式、最後回傳該物件;若省略 new,函式就會在全域上下文中執行。正因如此,業界發展出多種可以完全不用 new 的建構模式,值得進一步閱讀。
JavaScript 只有 Number 一種數值型別,對應 IEEE 754 的雙精度浮點數(64 位)。這帶來了著名的精度問題:
0.1 + 0.2 === 0.3 // false
由於整數與浮點沒有區別,下面這行反而是 true:
0.0 === 0; // true
還有一個更細的問題:規範允許 +0 與 -0 存在,兩者相等,但正負無窮大並不相等:
var a = 0 * 1; // 0
var b = 0 * -1; // -0
a === b; // true
1/a === 1/b; // false,Infinity 不等於 -Infinity
JavaScript 只有函式作用域,沒有區塊作用域。用 var 宣告在迴圈裡的變數,離開迴圈後依然存在:
for (var i = 0; i < 10; i++) {
console.log(i);
}
var i;
console.log(i); // 10
常見的建議是把所有變數宣告集中在函式開頭。若需要一個隔離的作用域,可以用立即呼叫的函式表達式:
(function () {
for (var i = 0; i < 10; i++) {
console.log(i);
}
}());
var i;
console.log(i); // undefined
另一個經典陷阱是宣告提升(hoisting)。下面這段程式看起來會輸出 5,實際上卻是 NaN:
var x = 3;
(function () {
console.log(x + 2); // NaN
var x = 0;
}());
因為 var x 會被提升到函式頂部,實際等同於:
var x = 3;
(function () {
var x; // 此時 x 為 undefined
console.log(x + 2); // NaN
x = 0;
}());
如果不小心在內部函式中重新宣告 x,就會踩到這個坑。反之,若只是指派而不宣告,就會改動外層的 x:
var x = 3;
(function () {
console.log(x + 2); // 5
x = 0; // 沒有 var,改的是外層的 x
}());
為程式建立命名空間時務必謹慎。存取全域變數需要沿著作用域鏈逐層查找,會帶來效能負擔;更嚴重的是,任何程式碼都能有意或無意地讀寫它,這正是跨站腳本攻擊(XSS)得以肆虐的土壤之一。
我曾看過有人試圖用一行宣告兩個區域變數:
var a = b = 3;
結果 a 是區域變數,b 卻被寫成了全域變數——因為 b = 3 先執行並產生了全域效果,再把結果 3 指派給 a。正確寫法應該是:
var a = 3, b = a;
this 通常指目前執行函式所屬的物件。但若函式不是作為物件方法被呼叫,例如在內部函式中,this 就會被設為全域物件:
var obj = {
doSomething: function () {
var a = "bob";
console.log(this); // 目前的物件 obj
(function () {
console.log(this); // window,this 被重設了
console.log(a); // "bob",仍在作用域內
}());
}
};
obj.doSomething();
這也是為什麼早期常看到 var self = this; 這種寫法。
JavaScript 用兩種狀態表示「沒有資料」,這讓從 C#、Java 轉過來的開發者相當困惑:
var a;
a === null; // false
a === undefined; // true
想確認變數是否真的有值,不能用 ==,而應明確比對:
if (a !== null && a !== undefined) { ... }
有些人會想說,既然 null 與 undefined 都是 falsy,直接 if (a) 不就夠了?問題是 0 與空字串也是 falsy,若它們本來就是合法值,就必須採用前一種寫法。簡短寫法只適合物件、陣列與布林值。
undefined 不是保留字,因此可以被覆寫:
undefined = "surprise!";
要取回真正的 undefined,可以指派 void 0:
undefined = void 0;
這正是 jQuery 原始碼開頭要這樣寫的原因:
(function (window, undefined) {
// jQuery 的程式碼
}(window));
呼叫時只傳入一個參數,就能確保第二個參數 undefined 真的是 undefined。順帶一提,null 無法被重定義,但 NaN、Infinity 以及內建型別都可以:
Array = function () { alert("hello!"); }
var a = new Array();
分號可以省略,讓初學者寫起來輕鬆些。但省略分號並不會真的讓任何人省事——當直譯器遇到錯誤時,反而得回頭猜測是哪一行漏了分號。最經典的例子是:
return
{ a: "hello" };
這段程式不會回傳物件,而是回傳 undefined,而且不會丟出任何錯誤,因為分號被自動補在 return 之後。這說明在 JavaScript 中,左大括號應該緊跟在該行結尾,而不是換行——這不只是程式風格問題。正確寫法是:
return { a: "hello" };
NaN 的型別是 number:
typeof NaN === "number" // true
而且它和任何值比較都是 false,包括它自己:
NaN === NaN; // false
要判斷某個值是否為 NaN,只能呼叫 isNaN()。另外,isFinite() 在運算元為 NaN 或 Infinity 時會回傳 false,也很實用。
除了不是真陣列之外,arguments 還有個特別之處:當函式簽名中有顯式的參數時,修改該參數會連帶改變 arguments 對應的值:
(function (a) {
alert(arguments[0]); // 1
a = 2;
alert(arguments[0]); // 2
}(1));
也就是說,arguments 指向的是變數本身,而不是一份初始值的副本。(在嚴格模式與 ES6 的參數設計下,這個連動行為已被取消。)
這些陷阱大多源自 JavaScript 早期為了「好上手」而做的設計取捨。好消息是,現代的解法相當明確:永遠用 ===、永遠寫出 parseInt 的基數、用 const/let 取代 var 取得區塊作用域、開啟嚴格模式、把全域變數降到最少,並善用 lint 工具在寫下問題程式碼的當下就攔住它。知道這些坑在哪裡,比記住所有怪異行為更重要。