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；“==” 会形成类型转换再进行比较， 不严谨。