摘要：原始類型值比較原始類型值有五種布爾值字符串數(shù)值。用來比較兩個值是否嚴格相等，與嚴格比較運算符的行為基本一致。返回布爾值，相等返回，不相等返回。

ES5 比較兩個值是否相等，只有兩個運算符：相等運算符（==）和嚴格相等運算符（===）。前者在比較時對于不同數(shù)據(jù)類型的值會進行類型轉(zhuǎn)換；而后者不會轉(zhuǎn)換，且結(jié)果更容易預測，并且因為沒有隱式轉(zhuǎn)換，全等比較的運行會更快。因此建議使用嚴格相等運算符===進行值的比較。

如果比較的兩個值的類型不同，直接返回false。

1 === "1"        // false
true === "true"  // false

原始類型值有五種：undefined、null、布爾值（Boolean）、字符串（String）、數(shù)值（Number）。

1. 非數(shù)值類型比較

值相同就返回true，值不同就返回false。

null === null        // true
null === undefined   // false

2. 數(shù)值類型比較

正常情況下值相同就返回true，值不同就返回false。但有兩個特殊情況：

一是0不分正負

0 === -0   //true

二是 NaN 本身不全等于任何值。

NaN === NaN   //false
NaN !== NaN   //true

也就是說 等式 (x !== x) 成立的唯一情況是 x 的值為 NaN。

復合類型的值實際上存儲的是數(shù)據(jù)的內(nèi)存地址，因此兩個復合類型（對象、數(shù)組、函數(shù)）的數(shù)據(jù)比較時，不是比較它們的值是否相等，而是比較它們是否指向同一個地址。

{} === {} // false
[] === [] // false
(function () {} === function () {}) // false

上面代碼分別比較兩個空對象、兩個空數(shù)組、兩個空函數(shù)，結(jié)果都是不相等。那是因為空對象、空數(shù)組、空函數(shù)的值，都存放在不同的內(nèi)存地址，因此結(jié)果是false。

而如果兩個變量引用同一個對象，那它們則相等，因為它們引用的對象存儲在同一個內(nèi)存地址。

var v1 = {};
var v2 = v1;
v1 === v2 // true

相等運算符用來比較相同類型的數(shù)據(jù)以及復合類型數(shù)據(jù)時，與嚴格相等運算符完全一樣。比較不同類型的數(shù)據(jù)時，相等運算符會先將數(shù)據(jù)進行類型轉(zhuǎn)換，然后再用嚴格相等運算符比較。

原始類型的值會轉(zhuǎn)換成數(shù)值再進行比較。轉(zhuǎn)換規(guī)則是使用 Number() 轉(zhuǎn)換。

1 == true // true    // 等同于 1 === Number(true)
0 == false // true  // 等同于 0 === Number(false)
"true" == true // false  // 等同于 Number("true") === Number(true)
"" == 0 // true         // 等同于 Number("") === 0
"" == false  // true  // 等同于 0 === 0
"
  123  	" == 123  // true  // 因為字符串轉(zhuǎn)為數(shù)字時，省略前置和后置的空格

undefined 和 null 與其他類型的值比較時，結(jié)果都為 false，它們互相比較時結(jié)果為 true。

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

對象（這里指廣義的對象，包括數(shù)組和函數(shù)）與原始類型的值比較時，對象轉(zhuǎn)換成原始類型的值，再進行比較。

1. 對象與數(shù)值比較時，對象轉(zhuǎn)為數(shù)值 Number()

[1] == 1 // true
// 等同于 Number([1]) == 1

2. 對象與字符串比較時，對象轉(zhuǎn)為字符串 String()

[1] == "1" // true
// 等同于 String([1]) == "1"
[1, 2] == "1,2" // true
// 等同于 String([1, 2]) == "1,2"

3. 對象與布爾值比較時，兩邊都轉(zhuǎn)為數(shù)值

[1] == true // true
// 等同于 Number([1]) == Number(true)
[2] == true // false
// 等同于 Number([2]) == Number(true)

相等運算符（==）和嚴格相等運算符（===）都有缺點，前者會自動轉(zhuǎn)換數(shù)據(jù)類型，后者的NaN不等于自身，以及+0等于-0。因此 ES6 的新方法Object.is可以用來解決這個問題。

Object.is 用來比較兩個值是否嚴格相等，與嚴格比較運算符（===）的行為基本一致。返回布爾值，相等返回 true，不相等返回 false。

不同之處只有兩個：一是+0不等于-0，二是NaN等于自身。

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

對于不兼容 ES6 的瀏覽器，可以在ES5 環(huán)境下通過下面的代碼，部署Object.is。

Object.defineProperty(Object, "is", {
  value: function(x, y) {
    if (x === y) {
      // 針對+0 不等于 -0的情況
      return x !== 0 || 1 / x === 1 / y;
    }
    // 針對NaN的情況
    return x !== x && y !== y;
  },
  configurable: true,
  enumerable: false,
  writable: true
});

判斷相等一覽表