JavaScript 中 == 和 === 的區別

兩個操做數之間的 " == " 與 " === "

一、 兩個不一樣的基本數據類型： 若是兩個基本數據類型（Number、String、Boolean、Null、Undefined）不一樣，會將它們進行數據類型轉化，再進行比較。例如：

0 == ''                                                  // true
0 == '0'                                                 // true
1 == '1'                                                 // true
'0' == ''                                                // false

false == 0                                               // true
false == '0'                                             // true
false == 'false'                                         // false
false == null                                            // false
true == null                                             // false
false == undefined                                       // false
true == undefined                                        // false
null == undefined                                        // true
NaN == NaN                                               // false

0 === ''                                                 // false
0 === '0'                                                // false
1 === '1'                                                // false

false === '0'                                            // false
null === undefined                                       // false

[] == false                                              // true
![] == false                                             // true
![] == []                                                // true
![] === []                                               // false

null === document.getElementById('ABC')                  // true（document.getElementById('ABC') 不存在）

二、 基本數據類型與引用數據類型： 將引用數據類型（function、object，其中object包含array）轉化（後臺自動調用 Object.prototype.valueOf() ）爲它的原始值，再進行比較。例如：

[1,2] == '0'                                            // true
function(){return ['1,2']}() == '1,2'                   // true

[1,2] === '0'                                           // false
function(){return ['1,2']}() === '1,2'                  // false

三、 兩個引用類型： 判斷二者之間的引用路徑。例如：

[1,2] == [1,2]                                          // false
[1,2] === [1,2]                                         // false

總結

一、" == " 狀況
通常轉化規則：（對象 => 字符串 => 數字值） 或 （布爾值 => 數字值）
（1）字符串與數字比較時，字符串轉化成數字值，兩者再進行比較。
（2）布爾值與數字比較時，布爾值轉化成數字值，兩者再進行比較。
（3）字符串與布爾值比較時，兩者所有轉化成數字值再進行比較。
（4）對象與數字比較時，對象先轉化成字符串，而後再轉化成數字值，與數字值進行比較。
（5）對象與字符串比較時，對象轉化成字符串，而後兩者再進行比較。
（6）對象和布爾值比較時，對象先轉化成字符串，而後再轉化成數字值，布爾值直接轉化爲數字，兩者再進行比較。
（7）null 與 undefined 兩者相等，不能把兩者轉化爲其餘值，兩者與其餘值比較返回 false。
（8）![] == []。（根據運算符的優先級，! 先執行，直接轉化爲布爾值（空字符串,NaN，0，null，undefined 都是 fasle，其他都是 true）再取反，故![] 轉化爲 false。其他依照以上規則轉化。最後 0 == 0，故結果爲 true。）

二、" === " 狀況
（1）兩個值類型不一樣，就返回 fasle 。
（2）兩個值都是數值，而且是同一個值，那麼爲 true，另外：若是其中至少一個是NaN，那麼爲 fasle。（判斷一個值是不是 NaN，只能使用 isNaN() 來判斷）；
（3）兩個值都是字符串，每一個位置的字符都同樣，那麼 true，不然 fasle。
（4）兩個值都引用同一個對象或函數，那麼爲true；不然 fasle。
（5）兩個值都是 true 或 fasle，那麼 true，不然 fasle。
（6）兩個值都是null 或 undefined，那麼爲true；不然 fasle。

結論：推薦使用 「===」， 只要類型不一致，直接返回 fasle；「==」 會形成類型轉換再進行比較， 不嚴謹。