摘要：所謂裝箱轉(zhuǎn)換，正是把基本類型轉(zhuǎn)換為對應(yīng)的對象，他是類型轉(zhuǎn)換中一種相當(dāng)重要的種類。拆箱轉(zhuǎn)換在標(biāo)準(zhǔn)中，規(guī)定了函數(shù)，它是對象類型到基本類型的轉(zhuǎn)換即，拆箱轉(zhuǎn)換。拆箱轉(zhuǎn)換會嘗試調(diào)用和來獲得拆箱后的基本類型。

ECMAScript 一共定義了七種 build-in types，其中六種為 Primitive Value，Null， Undefined，String， Number， Boolean， Symbol。而最后一種 Object build-in type 與通常意義上的 JavaScript 中 Object 并不一樣，總的來說，只要不屬于 Primitive Value 的值，就屬于 Object 類型，比如數(shù)組、對象、日期、正則、函數(shù)。

每一種基本類型 number, string, boolean, symbol 在 Object(build-in type) 中都有對應(yīng)的類。所謂裝箱轉(zhuǎn)換，正是把基本類型轉(zhuǎn)換為對應(yīng)的對象，他是類型轉(zhuǎn)換中一種相當(dāng)重要的種類。

JavaScript 語言設(shè)計上試圖模糊對象和基本類型之間的關(guān)系，比如，我們可以直接在基本類型上使用對象的方法：

console.log("abc".charAt()); // a

甚至我們在原型上添加方法，都可以應(yīng)用于基本類型。

實際上是 . 運(yùn)算符提供了裝箱操作，它會根據(jù)基礎(chǔ)類型構(gòu)造一個臨時對象，使得我們能在基礎(chǔ)類型上調(diào)用對應(yīng)對象的方法。

在 JavaScript 標(biāo)準(zhǔn)中，規(guī)定了 ToPrimitive 函數(shù)，它是對象類型到基本類型的轉(zhuǎn)換（即，拆箱轉(zhuǎn)換）。

對象到 String 和 Number 的轉(zhuǎn)換都遵循“先拆箱再轉(zhuǎn)換”的規(guī)則。通過拆箱轉(zhuǎn)換，把對象變成基本類型，再從基本類型轉(zhuǎn)換為對應(yīng)的 String 或者 Number。

拆箱轉(zhuǎn)換會嘗試調(diào)用 valueOf 和 toString 來獲得拆箱后的基本類型。如果 valueOf 和 toString 都不存在，或者沒有返回基本類型，則會產(chǎn)生類型錯誤 TypeError。

ToPrimitive 用于將 Object 轉(zhuǎn)為 Primitive Value

對于我們平常遇到的 Object，其處理邏輯是：

調(diào)用 Object.valueOf，如果結(jié)果是 Primitive Value，則返回;

調(diào)用 Object.toString，如果結(jié)果是 Primitive Value，則返回;

都不是，返回 TypeError

普通對象和數(shù)組的這兩個方法返回的結(jié)果如下：

var a = [12]
var b = {a: 123}

// [12]
a.valueOf()

// "12"
a.toString()

// {a: 123}
b.valueOf()

// "[object Object]"
b.toString()

如上，兩者的 valueOf 返回的都不是 Primitive Value (返回了自身，還是 Object 類型)。那么，根據(jù)規(guī)范，兩者調(diào)用 ToPrimitive 返回的將是一個 字符串。

這個方法用于將不是 Boolean 類型的值轉(zhuǎn)換為 Boolean 類型。

Undefined 返回 false

Null 返回 false

所有 Object 類型都會被轉(zhuǎn)換為 true;

Number 類型中，0，NaN 會被轉(zhuǎn)換為 false，其它都為 true

只有空字符串為 false，其它都為 true

其它類型轉(zhuǎn)換為 Number 類型。

Undefined 返回 NaN

Null 返回 0

Boolean 類型，true 為 1； false 為 0

String 類型，如果滿足數(shù)字語義則轉(zhuǎn)為數(shù)字，否則轉(zhuǎn)換為 NaN

Object 類型，先轉(zhuǎn)換為 Primitive Value 再遞歸調(diào)用自身 ToNumber 來轉(zhuǎn)換。

// "56" ==> 56
Number([56])

// ",56" ==> NaN
Number([,56])

// "55,56" ==> NaN
Number([55, 56])

Number 返回 對應(yīng)數(shù)值字符串

Boolean 返回字符串 “true” 或者 “false”

Undefined 返回 “undefined”

Null 返回 “null”

了解了上面的知識，可以開始進(jìn)入我們的正題了，在 JavaScript 中可以觸發(fā)隱式類型轉(zhuǎn)換的操作有：

四則運(yùn)算: +, -, *, /

比較運(yùn)算符: ==, <, >, >=, <=

判斷語句: if, while

Native調(diào)用: console, alet 輸入時會自動轉(zhuǎn)換成 String 類型

邏輯非 !，將直接調(diào)用 ToBoolean 方法，然后取反返回。

如果 Type 相同，等價于 A === B

特別的, undefined == null

String == Number，則把 String 轉(zhuǎn)換成 Number

有 Boolean 值的，將 Boolean 轉(zhuǎn)換成 Number

Object String/Number/Symbol，將 Object 轉(zhuǎn)換成 Primitive Value

否則，返回 false

// "12" ==> 12;
// 返回 true
12 == "12"

// 轉(zhuǎn) boolean: [] == 0
// 轉(zhuǎn) object: "" == 0
// 轉(zhuǎn) string: 0 == 0
// 返回 true
[] == false

// 轉(zhuǎn) object: "45" == 45
// 轉(zhuǎn) string: 45 == 45
// 返回 true
[45] == 45

// 單目: {} == false
// 轉(zhuǎn) boolean: {} == 0
// 轉(zhuǎn) object: "[object Object]" == 0
// 轉(zhuǎn) string: NaN == 0
// 返回 false
{} == !{}

// 單目：[] == fasle
// 轉(zhuǎn) boolean： [] == 0
// 轉(zhuǎn) array: "" == 0
// 轉(zhuǎn) string: 0 == 0
// 返回 true
[] == ![]

[] == []
[] == 0

類型不同，直接返回 false

Number 類型判斷：有 NaN 就 false；

特別的 +0 === -0；

最后調(diào)用 SameValueNonNumber

另外 != 和 !== 則是指出了 A != B 與 !(A == B) 是完全等價的。在判斷 !=/!== 時，其實就是在判斷 ==/===.

兩邊操作數(shù)調(diào)用 ToPrimitive 轉(zhuǎn)換為 Primitive Value

由于 Primitive Value 出來有 String 和 Number 兩種結(jié)果，分別有不同的比較規(guī)則；

如果兩邊的值都是 String，則 按 code unit 比較，

如果一邊是 Number，則將另一邊也轉(zhuǎn)換為 Number;注意 Number 需要處理 +0/-0/NaN/Infinity 等情況

// 注意轉(zhuǎn)換后為 "45" < "46"
// 按字符串規(guī)則比較 最終比較的是 "5".charCodeAt() < "6".charCodeAt() => 53 < 54
// 返回 true
[45] < [46]

// 同理 [10] < [9] 最后進(jìn)行的是 "10" < "9" 的比較，是字符串之間的筆記，不會轉(zhuǎn)換為數(shù)字間的比較，
// 其實最終比較的是 "1".charCodeAt() < "9".charCodeAt() => 49 < 57.
[10] < [9]

// 每個表達(dá)式是 true 還是 false 呢？為啥呢？

// 初階
!{}
12 == "12"
"false" == false
null == undefined

// 高階
[] == []
[] == false
[] === false
[45] == 45

// 終階
[45] < [46] ?
[10] < [9] ?
{} == !{}
{} != {}
-0 === +0
NaN === NaN
NaN != NaN

// 轉(zhuǎn)換條件 轉(zhuǎn)換后類型 結(jié)果
[]+[] // String “”
[1,2]+[3,4] // String “1,23,4”
[]+{} // String “[object Object]”
[1,2] + {a:1} // String “1,2[object Object]”
{}+[] // Number 0
{}+[1] //Number 1
{a:1}+[1,2] // Number NaN
{a:1}+{b:2} // Chrome - String “[object Object][object Object]” (背后實現(xiàn)eval)
{a:1}+{b:2} // Firefox - Number NaN
true+true // Number 2
1+{a:1} // String “1[object Object]”

JavaScript 中的隱式類型轉(zhuǎn)換的規(guī)范

JavaScript 運(yùn)算符規(guī)則與隱式類型轉(zhuǎn)換詳解

JavaScript類型：關(guān)于類型，有哪些你不知道的細(xì)節(jié)？

深入淺出弱類型JS的隱式轉(zhuǎn)換

JavaScript字符串間的比較

ecma-sec-relational-operators