比较运算符之相等运算符

ES5 比较两个值是否相等，只有两个运算符：相等运算符（==）和严格相等运算符（===）。前者在比较时对于不同数据类型的值会进行类型转换；而后者不会转换，且结果更容易预测，并且因为没有隐式转换，全等比较的运行会更快。因此建议使用严格相等运算符===进行值的比较。

严格相等运算符 ===

（1） 不同类型的值比较

如果比较的两个值的类型不同，直接返回false。

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

（2） 原始类型值比较

原始类型值有五种：undefined、null、布尔值（Boolean）、字符串（String）、数值（Number）。

1. 非数值类型比较

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

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

2. 数值类型比较

正常情况下值相同就返回true，值不同就返回false。但有两个特殊情况：

@H_126_72@一是0不分正负

0 === -0   //true

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

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

也就是说 等式 (x !== x) 成立的唯一情况是 x 的值为 NaN。

(3) 复合类型值比较

复合类型的值实际上存储的是数据的内存地址，因此两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址。

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

上面代码分别比较两个空对象、两个空数组、两个空函数，结果都是不相等。那是因为空对象、空数组、空函数的值，都存放在不同的内存地址，因此结果是false。

而如果两个变量引用同一个对象，那它们则相等，因为它们引用的对象存储在同一个内存地址。

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

相等运算符 ==

相等运算符用来比较相同类型的数据以及复合类型数据时，与严格相等运算符完全一样。比较不同类型的数据时，相等运算符会先将数据进行类型转换，然后再用严格相等运算符比较。

（1） 原始类型值比较

原始类型的值会转换成数值再进行比较。转换规则是使用 Number() 转换。

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
'n  123  t' == 123  // true  // 因为字符串转为数字时，省略前置和后置的空格

（2） undefined 和 null

undefined 和 null 与其他类型的值比较时，结果都为 false，它们互相比较时结果为 true。

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

（3） 对象与原始类型值比较

对象（这里指广义的对象，包括数组和函数）与原始类型的值比较时，对象转换成原始类型的值，再进行比较。

1. 对象与数值比较时，对象转为数值 Number()

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

2. 对象与字符串比较时，对象转为字符串 String()

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

3. 对象与布尔值比较时，两边都转为数值

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

Object.is(value1, value2)

相等运算符（==）和严格相等运算符（===）都有缺点，前者会自动转换数据类型，后者的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 环境下通过下面的代码，部署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
});

判断相等一览表