原文作者:Andy Croxall 原文鏈接:Ten Oddities And Secrets About JavaScript 翻譯編輯:張鑫旭
JavaScript 有一個 Null 類型,它只有一個值 null(也就是它自己的字面量),語義是「完全沒有任何意義的值」。但它的表現很像對象:
alert(typeof null); // 彈出 'object'

儘管 typeof 顯示 "object",null 並不被認為是一個對象實例。要知道在 JavaScript 中,值都是某個構造函數的實例:每個數值都是 Number 的實例,每個字符串都是 String 的實例,所有對象都是 Object 的實例。而 null 是沒有值的,所以它不會是任何東西的實例:
alert(null instanceof Object); // false
譯者注:也有人把 null 理解為「對象佔位符」,這樣就好接受多了。
NaN 的字面意思是「這不是一個數值」,但它本身的類型卻是數值,並且它不等於自身:
alert(typeof NaN); // 彈出 'Number' alert(NaN === NaN); // false


實際上 NaN 不等於任何東西,包括它自己。要判斷某個值是不是 NaN,唯一可靠的办法是 isNaN()。
這是 JavaScript 最讓人頭疼的一個怪癖:
alert(new Array() == false); // true

要理解這裡發生了什麼,得先搞懂 truthy 和 falsy。JavaScript 中所有的非布爾值都內置了一個布爾標誌,當這個值被要求表現出布爾行為時(例如跟布爾值做比較),這個內置標誌就會出場。
因為蘋果沒法跟梨比,所以當兩個不同類型的值做比較時,JavaScript 會先把它們弱化成相同類型。false、undefined、null、0、""、NaN 都會弱化成 false。這種強制轉換並非無時無刻都在發生,只在作為表達式使用時才會觸發:
var someVar = 0; alert(someVar == false); // true

你可能注意到了,上面那串「等於 false」的清單裡並沒有空數組。這正是空數組的怪異之處:它本身屬於 truthy,但與布爾值比較時行為又表現得像 falsy。
var someVar = []; // 空數組
alert(someVar == false); // true
if (someVar) alert('hello'); // 這句 alert 會執行,說明 someVar 被當作 true


譯者注:作者的解釋是數組內置了 toString() 方法,直接 alert 時會以 join(",") 的形式輸出字符串,空數組自然變成空字符串,於是等同 false。可參見作者另一篇文章《Twisted logic: understanding truthy & falsy》。
想避開強制轉換帶來的困擾,比較時請一律使用強等於(===):
var someVar = 0; alert(someVar == false); // true —— 0 屬於 falsy alert(someVar === false); // false —— 0 是數值,不是布爾值


想深入瞭解這類強制轉換規則,可以查 ECMA-262 規範的 section 11.9.3。
這是 JavaScript 最鮮為人知的秘密之一,從 v1.3 就引入了。大多數時候我們這樣用它:
alert('10 13 21 48 52'.replace(/\d+/g, '*')); // 把所有數字換成 *
但如果我們希望替換過程帶點判斷——比如只替換 30 以下的數值——單靠正則就無能為力了。這時可以傳入一個回調函數:
alert('10 13 21 48 52'.replace(/\d+/g, function(match) {
return parseInt(match) < 30 ? '*' : match;
}));
每完成一次匹配,JavaScript 就調用這個函數,把匹配內容傳給 match 參數。函數返回什麼,就用什麼來替換。

很多工程師跟正則打交道僅限於這兩個方法,其實還有很多。特別值得一提的是 test():它的工作方式類似 match(),但返回布爾值,只關心「有沒有匹配」,因此執行效率更高。
alert(/\w{3,}/.test('Hello')); // true,因為至少有 3 個字母

另外別忘了 RegExp 對象,可以用它動態構造正則:
function findWord(word, string) {
var instancesOfWord = string.match(new RegExp('\\b' + word + '\\b', 'ig'));
alert(instancesOfWord);
}
findWord('car', 'Carl went to buy a car but had forgotten his credit card.');
這裡基於參數 word 動態生成了匹配表達式,並用 \b 限定單詞邊界,所以 Carl 不會被匹配進來,只會選出單獨的 car。

作用域決定哪些變量可用。獨立的 JavaScript 代碼運行在 window 對象的全局作用域下,而函數內聲明的局部變量只能在函數內使用。
var animal = 'dog';
function getAnimal(adjective) { alert(adjective + ' ' + this.animal); }
getAnimal('lovely'); // 彈出 'lovely dog'
這裡變量和函數都在全局作用域中,this 指向當前作用域也就是 window,所以 this.animal 就是 window.animal 即 'dog'。但實際上,我們可以讓函數運行在完全不同的作用域下,無視它自身所處的作用域——這就要用到 call():
var animal = 'dog';
function getAnimal(adjective) { alert(adjective + ' ' + this.animal); };
var myObj = { animal: 'camel' };
getAnimal.call(myObj, 'lovely'); // 彈出 'lovely camel'
call() 的第一個參數可以冒充函數中的 this,所以 this.animal 實際上就是 myObj.animal 也就是 'camel',後面的參數則作為普通參數傳入。
與之相關的還有 apply(),作用與 call() 完全一樣,唯一區別是傳給函數的參數以數組形式給出:
getAnimal.apply(myObj, ['lovely']); // 參數以數組形式發送

點擊第二、第三個按鈕的結果:

(function() { alert('hello'); })(); // 彈出 'hello'
解析過程很簡單:聲明一個函數,後面的 () 讓它立即執行。乍看有點自相矛盾——函數存在的意義通常是「稍後執行」,而不是解析到就立刻跑。
但立即執行函數(self-executing functions,SEF)有個非常實用的場景:在延遲執行中鎖定變量的當前值。比如事件回調、setTimeout、setInterval:
var someVar = 'hello';
setTimeout(function() { alert(someVar); }, 1000);
var someVar = 'goodbye';
新手常在論壇問:這裡為什麼彈出 goodbye 而不是 hello?答案是計時器裡的回調函數直到真正執行時才去讀 someVar,而那時它早就被改成 goodbye 了。
SEF 提供了一個優雅的解法:把 someVar 當作參數傳進去,等於把它的值傳入並隔離起來,後續無論外部怎麼變都與我無關:
var someVar = 'hello';
setTimeout((function(someVar) {
return function() { alert(someVar); }
})(someVar), 1000);
var someVar = 'goodbye';
這一次彈出的就是 hello 了。這就是「函數參數」和「外部變量」在本質上的差別。

直到現在我也沒真正理解 Mozilla 為什麼要這樣做。看個例子:
<!--
#somePara { color: #f90; }
-->
<p id="somePara">Hello, world!</p>
<script>
var ie = navigator.appVersion.indexOf('MSIE') != -1;
var p = document.getElementById('somePara');
alert(ie ? p.currentStyle.color : getComputedStyle(p, null).color);
</script>
大部分瀏覽器彈出的是 ff9900,而 Firefox 彈出的是 rgb(255, 153, 0)。所以處理顏色時,經常不得不額外寫一段把 RGB 轉成 Hex 的代碼。


這個問題不只困擾 JavaScript,它是計算機科學裡的通用難題,影響了幾乎所有語言。標題那個等式實際輸出 0.30000000000000004。
這被稱為機器精度問題。當 JavaScript 執行 (0.1 + 0.2) 時,會把值轉換成它們最擅長的二進制形式。問題就出在這裡:0.1 在二進制下並不是精確的 0.1,它是一個無限循環小數,必須被截斷。從本質上說,當你寫下這些小數時,它們就註定要失去精度。
好比你想把一段文字翻譯成簡體中文,結果出來的是帶著差異的繁體——意思對得上,字符卻不完全一樣。
實務上通常有兩種應對方式:
// 不應該這樣寫 var num1 = 0.1, num2 = 0.2, shouldEqual = 0.3; alert(num1 + num2 == shouldEqual); // false // 而應該這樣寫 alert(num1 + num2 > shouldEqual - 0.001 && num1 + num2 < shouldEqual + 0.001); // true
用一個和風細雨的小古怪收尾。聽起來有點繞:undefined 並不是 JavaScript 的保留字,儘管它有特殊含義,而且是判斷變量是否未定義的唯一方法。因此下面這段完全合法:
var someVar; alert(someVar == undefined); // true
目前一切風平浪靜。但劇情總是很狗血:
undefined = "I'm not undefined!"; var someVar; alert(someVar == undefined); // false!
這就是為什麼 jQuery 源碼最外層那個閉包函數要聲明一個並未傳入的 undefined 參數——目的就是在函數作用域內保護 undefined 不被外部污染。一個極小的技巧,擋住了一整類難以排查的 bug。
