DIV CSS 佈局教程網

JavaScript 裡那些容易踩到的坑
編輯:關於JavaScript     

JavaScript 是全世界使用最廣泛的語言之一,但它同時也有相當古怪的一面。開發者在用它寫程式的過程中,難免會遇到一些令人哭笑不得的「特性」。即使是經驗豐富的老手,看到下面這些例子大概也會心一笑。

函式與運算子

雙等號會進行型別轉換

== 在比較時會先做型別強制轉換,因此它能比較兩個型別不同的值——在比較之前,它會先設法把兩邊轉成同一型別:

"1" == 1  // true

這往往會誤導人,而且大多數時候我們並不需要這種行為。與其依賴隱含轉換,不如明確地先轉型再比較:

Number("1") === 1;  // true

更好的做法是確保放在前面的運算元本來就是你要的型別。

更麻煩的是,== 會破壞遞移律,這點相當危險:

"" == 0     // true,空字串被轉成數字 0
0 == "0"    // true,數字 0 被轉成字串 "0"
"" == "0"   // false,兩邊都是字串,不進行轉換

若改用 ===,上面三個比較全部會是 false。

parseInt 的基數問題

若省略第二個參數,基數依下列規則決定:

  • 預設為 10,即按十進位解析。
  • 以 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 回傳的是基本型別的類型名稱。陣列其實不是基本型別,因此:

typeof {} === "object"    // true
typeof "" === "string"    // true
typeof [] === "array"     // false,實際回傳 "object"

另外,typeof null 會回傳 "object",這是語言設計早期留下的著名怪異行為。

instanceof 與字面語法

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 不是真的陣列

函式中的 arguments 以類陣列形式傳入,有 length 屬性,索引從 0 開始,但它並不是 Array。可以這樣轉成真陣列:

var args = Array.prototype.slice.call(arguments, 0);

由 getElementsByTagName 回傳的 NodeList 也適用同樣的手法。

eval

eval 會把字串當成 JavaScript 程式碼執行,一般並不建議使用。原因有三:其一,速度很慢——腳本載入時已被編譯成原生碼,而每次執行到 eval,編譯流程就得重新跑一遍;其二,寫法醜陋且容易被濫用;其三,eval 中的程式碼會在當前作用域執行,因此能修改區域變數,甚至在你的作用域裡塞進意料之外的東西。

JSON 轉換是常見需求,過去常寫成 var obj = eval(jsonText);。如今幾乎所有瀏覽器都支援原生 JSON 物件,改用 JSON.parse(jsonText) 更安全,反向轉換則用 JSON.stringify()。

另外,setTimeout 與 setInterval 的第一個參數可以傳字串作為函式主體,但同樣不建議,直接傳函式才是正解。Function 建構式與 eval 類似,差別只在於它是在全域作用域中執行。

with

with 提供存取物件屬性的簡寫方式,但是否該用始終有爭議。它的問題在於可讀性:

with (obj) {
  bob = "mmm";
  eric = 123;
}

看到這段程式,你無法立刻判斷究竟發生什麼事。你剛剛改的是區域變數 bob,還是設定了 obj.bob?如果 obj.bob 已存在,它會被重設為 "mmm";否則可能改到外層的 bob,再不然就是新增了一個全域變數。相比之下,寫成下面這樣意思清楚得多:

obj.bob = "mmm";
obj.eric = 123;

ECMAScript 5 的嚴格模式已經不允許使用 with。

型別與建構函式

不必要的 new

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

如果你自訂了建構函式卻漏掉 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 通常指目前執行函式所屬的物件。但若函式不是作為物件方法被呼叫,例如在內部函式中,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; 這種寫法。

雜項陷阱

null 與 undefined

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 不是保留字,因此可以被覆寫:

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 的怪異之處

NaN 的型別是 number:

typeof NaN === "number"  // true

而且它和任何值比較都是 false,包括它自己:

NaN === NaN;  // false

要判斷某個值是否為 NaN,只能呼叫 isNaN()。另外,isFinite() 在運算元為 NaN 或 Infinity 時會回傳 false,也很實用。

arguments 的第二個怪癖

除了不是真陣列之外,arguments 還有個特別之處:當函式簽名中有顯式的參數時,修改該參數會連帶改變 arguments 對應的值:

(function (a) {
  alert(arguments[0]);  // 1
  a = 2;
  alert(arguments[0]);  // 2
}(1));

也就是說,arguments 指向的是變數本身,而不是一份初始值的副本。(在嚴格模式與 ES6 的參數設計下,這個連動行為已被取消。)

結語

這些陷阱大多源自 JavaScript 早期為了「好上手」而做的設計取捨。好消息是,現代的解法相當明確:永遠用 ===、永遠寫出 parseInt 的基數、用 const/let 取代 var 取得區塊作用域、開啟嚴格模式、把全域變數降到最少,並善用 lint 工具在寫下問題程式碼的當下就攔住它。知道這些坑在哪裡,比記住所有怪異行為更重要。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved