有趣的JavaScript隐式類型轉換

JavaScript的資料類型是非常弱的（不然不會叫它做弱類型語言了）！在使用算術運算符時，運算符兩邊的資料類型可以是任意的，比如，一個字元串可以和數字相加。之是以不同的資料類型之間可以做運算，是因為JavaScript引擎在運算之前會悄悄的把他們進行了隐式類型轉換的，如下是數值類型和布爾類型的相加：

3 + true; // 4      

結果是一個數值型！如果是在C或者Java環境的話，上面的運算肯定會因為運算符兩邊的資料類型不一緻而導緻報錯的！但是，在JavaScript中，隻有少數情況下，錯誤類型才會導緻出錯，比如調用非函數，或者讀取null或者undefined的屬性時，如下：

"hello"(1); // error: not a functionnull.x; // error: cannot read property 'x' of null      

多數情況下，JavaScript都不會出錯的，而是自動的進行相應的類型轉換。比如-, *, /,和%等算術運算符都會把操作數轉換成數字的，但是“+”号就有點不一樣了，有些情況下，它是算術加号，有些情況下，是字元串連接配接符号，具體的要看它的操作數，如下：

2 + 3; // 5"hello" + " world"; // "hello world"      

但是，如果字元串和數字相加，會是怎樣的結果呢？JavaScript會自動把數字轉換成字元的，不管數字在前還是字元串在前，如下：

"2" + 3; // "23"2 + "3"; // "23"      

字元串和數字相加結果是字元串，字元串和數字相加結果是字元串，字元串和數字相加結果是字元串，重要的事情說三遍！！！！！！

此外，需要注意的是，“+”的運算方向是從左到右的，如下：

1 + 2 + "3"; // "33"      

這與下面是等價的：

(1 + 2) + "3"; // "33"      

相比之下，下面的結果是不一樣的：

1 + "2" + 3; // "123"      

但是，隐式類型轉換，有時候，會隐藏一些錯誤的，比如，null會轉換成0，undefined會轉換成NaN。需要注意的是，NaN和NaN是不相等的（這是由于浮點數的精度決定的），如下：

var x = NaN;
x === NaN; // false      

雖然，JavaScript提供了isNaN來檢測某個值是否為NaN，但是，這也不太精确的，因為，在調用isNaN函數之前，本身就存在了一個隐式轉換的過程，它會把那些原本不是NaN的值轉換成NaN的，如下：

isNaN("foo"); // trueisNaN(undefined); // trueisNaN({}); // trueisNaN({ valueOf: "foo" }); // true      

上面代碼，我們使用isNaN來測試後，發現字元串，undefined，甚至對象，結果都傳回真！！！但是，我們總不能說他們也是NaN吧？總而言之，得出的結論是：isNaN檢測NaN并不可靠！！！

幸運的是，有一種可靠的并且準确的方法可以檢測NaN。我們都知道，隻有NaN是自己不等自己的，那麼，我們就以使用不等于号（！==）來判斷一個數是否等于自身，進而，可以檢測到NaN了，如下：

var a = NaN;
a !== a; // truevar b = "foo";
b !== b; // falsevar c = undefined;
c !== c; // falsevar d = {};
d !== d; // falsevar e = { valueOf: "foo" };
e !== e; // false      

我們也可以把這種模式定義成一個函數，如下：

function isReallyNaN(x) {    return x !== x;
}      

OK,NaN的檢測方法就是這麼簡單，我們下面繼續讨論對象的隐式轉換！

對象是可以轉換成原始值的，最常見的方法就是把它轉換成字元串，如下：

"the Math object: " + Math; // "the Math object: [object Math]""the JSON object: " + JSON; // "the JSON object: [object JSON]"      

對象轉換成字元串是調用了他的toSting函數的，你可以手動的調用它來檢測一下：

Math.toString(); // "[object Math]"JSON.toString(); // "[object JSON]"      

類似的，對象也是可以轉換成數字的，他是通過valueOf函數的，當然，你也是可以自定義這個valueOf函數的，如下：

"J" + { toString: function() { return "S"; } }; // "JS"2 * { valueOf: function() { return 3; } }; // 6      

如果，一個對象同時存在valueOf方法和toString方法，那麼，valueOf方法總是會被優先調用的，如下：

var obj = {
    toString: function() {        return "[object MyObject]";
    },
    valueOf: function() {        return 17;
    }
};
"object: " + obj; // "object: 17"      

但是，多數情況下，這都不是我們想要的，一般的，盡可能使valueOf和toString表示的值相同（盡管類型可以不同）。 

最後一種強制類型轉換，我們常常稱之為“真值運算”，比如，if, ||, &&，他們的操作數不一定是布爾型的額。JavaScript會通過簡單的轉換規則，将一些非布爾類型的值轉換成布爾型的。大多數的值都會轉換成true，隻有少數的是false，他們分别是：false, 0, -0, "", NaN, null, undefined，因為存在數字和字元串以及對象的值為false，是以，直接用真值轉換來判斷一個函數的參數是否傳進來了，這是不不×××全的。比如，有一個可以具有預設值得可選參數的函數，如下：

function point(x, y) {if (!x) {
    x = 320;
}if (!y) {
    y = 240;
}    return { x: x, y: y };
}      

這個函數會忽略任何的真值為假的參數的，包括0，-0；

point(0, 0); // { x: 320, y: 240 }      

檢測undefined的更加準确的方法是用typeof操作：

function point(x, y) {if (typeof x === "undefined") {
    x = 320;
}if (typeof y === "undefined") {
    y = 240;
}    return { x: x, y: y };
}      

這種寫法，可以區分開0和undefined的：

point(); // { x: 320, y: 240 }point(0, 0); // { x: 0, y: 0 }      

另外一種方法是利用參數跟undefined作比較，如下：

if (x === undefined) { ... }      

總結:

1. 類型錯誤有可能會被類型轉換所隐藏。

2. “+”既可以表示字元串連接配接，又可以表示算術加，這取決于它的操作數，如果有一個為字元串的，那麼，就是字元串連接配接了。

3. 對象通過valueOf方法，把自己轉換成數字，通過toString方法，把自己轉換成字元串。