隱式類型轉換

本篇文章給大家帶來的內容是關於什么是隱式類型轉換？js隱式類型轉換的介紹，有一定的參考價值，有需要的朋友可以參考一下，希望對你有所幫助。

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

1 2	`3 +` `true;` `// 結果：4`

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

"hello"(1); 
//結果： error: not a function
null.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	`1 + 2 +` `"3";` `// "33"`

這與下面是等價的：

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

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

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

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

1 2	`var` `x = NaN;` `x === NaN;` `// false`

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

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

上面代碼，我們使用isNaN來測試后，發現字符串，undefined，甚至對象，結果都返回真！！！但是他們不是NaN。

總而言之：isNaN檢測NaN並不可靠！！！

有一種可靠的並且准確的方法可以檢測NaN。

我們都知道，只有NaN是自己不等自己的，可以使用不等於號（！==）來判斷一個數是否等於自身，從而，可以檢測到NaN了，如下：

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

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

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

對象的隱式轉換

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

1 2	`"the Math object: "` `+ Math;` `// "the Math object: [object Math]"` `"the JSON object: "` `+ JSON;` `// "the JSON object: [object JSON]"`

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

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

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

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

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

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

一般的，盡可能使value Of和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；

1	`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的：

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

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

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

總結:

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

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

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

4.具有value Of方法的對象，應該定義一個相應的toString方法，用來返回相等的數字的字符串形式。

5.檢測一些未定義的變量時，應該使用type Of或者與undefined作比較，而不應該直接用真值運算。

什么是隱式類型轉換？js隱式類型轉換的介紹

對象的隱式轉換

免責聲明！