宽松相等（loose equals） == 和严格相等（strict equals） === 都用来判断两个值是否“相等”，但是它们之间有一个很重要的区别，特别是在判断条件上。
常见的误区是“ == 检查值是否相等， === 检查值和类型是否相等”。听起来蛮有道理，然而还不够准确。很多 JavaScript 的书籍和博客也是这样来解释的，但是很遗憾他们都错了。
正确的解释是：“ == 允许在相等比较中进行强制类型转换，而 === 不允许。”
上面两种解释的区别：
- 第一种解释（不准确的版本）， === 似乎比 == 做的事情更多，因为它还要检查值的类型。
- 第二种解释中 == 的工作量更大一些，因为如果值的类型不同还需要进行强制类型转换。
但是，
- 虽然强制类型转换确实要多花点时间，但仅仅是微秒级（百万分之一秒）的差别而已。
- == 和 === 都会检查操作数的类型。真正的区别在于操作数类型不同时它们的处理方式不同。
拓展知识点：
1. 存在 宽松不相等（loose not-equality） != 就是 == 的相反值， 严格不相等 !== 同理
2. 两个值的类型相同时，则仅比较它们是否相等，不发生强制类型转换。此时宽松相等与严格相等并无区别
3. 两个值的类型不相同时，宽松相等判断会进行类型转换后 再进行判断比较。而转换的类型顺序总结下来是：
① 若存在一个为字符串类型，另一个可直接转换为字符串类型 进行比较；
② 若存在一个为数字类型A，另一个为非数字类型B，则非数字类型B 需转换为数字类型后再比较，即 ToNumber(B) == A。
4. 判断使用建议：
var a = "42";
// 不要这样用，条件判断不成立：
if (a == true) {
// ..
}
// 也不要这样用，条件判断不成立：
if (a === true) {
// ..
}
// 这样的显式用法没问题：
if (a) {
// ..
}
// 这样的显式用法更好：
if (!!a) {
// ..
}
// 这样的显式用法也很好：
if (Boolean( a )) {
// ..
}
建议无论什么情况下都不要使用 == true 和 == false !!
5. 对象和非对象之间的相等比较
JS 的“拆封”：即“打开”封装对象（如 new String("abc") ），返回其中的基本数据类型值（ "abc" ）。
而 == 中的 ToPromitive 强制类型转换也会发生这样的情况：先将对象类型的数据 调用 ToPromitive 抽象操作，取出对象中 valueOf() 的返回值，再根据实际需要进行强制类型转换后 进行比较。
e.g.
var a = "abc";
var b = Object( a ); // 和new String( a )一样
a === b; // false
a == b; // true
a == b 结果为 true ，因为 b 通过 ToPromitive 进行强制类型转换（也称为“拆封”，英文为 unboxed 或者 unwrapped），并返回标量基本类型值 "abc" , 与 a 相等.
PS:
• NaN 不等于 NaN ( JS 数据类型中 唯一跟自身不相等的类型)
• +0 等于 -0
但是，也有一些值不这样，原因是 == 算法中其他优先级更高的规则。
e.g.：
var a = null;
var b = Object( a ); // 和Object()一样
a == b; // false
var c = undefined;
var d = Object( c ); // 和Object()一样
c == d; // false
var e = NaN;
var f = Object( e ); // 和new Number( e )一样
e == f; // false
因为没有对应的封装对象，所以 null 和 undefined 不能够被封装（boxed）， Object(null) 和 Object() 均返回一个常规对象。NaN 能够被封装为数字封装对象，但拆封之后 NaN == NaN 返回 false ，因为 NaN 不等于 N
6. 宽松相等比较 需要特别注意的 情况
① null 和 undefined 之间的相等比较
需要注意到 在 == 中 null 和 undefined 相等（它们也与其自身相等），除此之外其他值都不存在这种相等的情况 !!
e.g.
var a = null;
var b;
a == b; // true
a == null; // true
b == null; // true
a == false; // false
b == false; // false
a == ""; // false
b == ""; // false
a == 0; // false
b == 0; // false
② 下面罗列了比较特别的判断情况，需要注意标注 晕 的数据
"0" == null; // false
"0" == undefined; // false
"0" == false; // true -- 晕！
"0" == NaN; // false
"0" == 0; // true
"0" == ""; // false
false == null; // false
false == undefined; // false
false == NaN; // false
false == 0; // true -- 晕！
false == ""; // true -- 晕！
false == []; // true -- 晕！
false == {}; // false
"" == null; // false
"" == undefined; // false
"" == NaN; // false
"" == 0; // true -- 晕！
"" == []; // true -- 晕！
"" == {}; // false
0 == null; // false
0 == undefined; // false
0 == NaN; // false
0 == []; // true -- 晕！
0 == {}; // false
③
e.g.1： [] == ![] // true
上面例子里 ！运算符做的操作是：根据 ToBoolean 规则，它会进行布尔值的显式强制类型转换（同时反转奇偶校验位）。所以 [] == ![] 变成了 [] == false 。前
面我们讲过 false == [] ，最后的结果就顺理成章了.
e.g.2:
2 == [2]; // true
"" == [null]; // true
上面例子中，== 右边的值 [2] 和 [null] 会进行 ToPrimitive 强制类型转换，以便能够和左边的基本类型值（ 2 和 "" ）进行比较。因为数组的 valueOf() 返回数组本身，
所以强制类型转换过程中数组会进行字符串化。
第一行中的 [2] 会转换为 "2" ，然后通过 ToNumber 转换为 2 。
第二行中的 [null] 会直接转换为 "" 。
所以最后的结果就是 2 == 2 和 "" == "" 。
e.g.3:
0 == "\n"; // true
"" 、 "\n" （或者 " " 等其他空格组合）等空字符串被 ToNumber 强制类型转换为 0 ，故上面例子的比较结果为true.
④ 整理上面内容，
建议无论什么情况下都不要使用 == true 和 == false 做为判断 !!， 如下
"0" == false; // true -- 晕！
false == 0; // true -- 晕！
false == ""; // true -- 晕！
false == []; // true -- 晕！
"" == 0; // true -- 晕！
"" == []; // true -- 晕！
0 == []; // true -- 晕
宽松判断时，注意避免 值为 “ ”、[]、0 的情况， 如下
"" == 0; // true -- 晕！
"" == []; // true -- 晕！
0 == []; // true -- 晕！
日常写的方法函数中，需要注意
function doSomething(a) {
if (a == "") {
// ..
}
}
如果碰到 doSomething(0) 和 doSomething([]) 这样的情况，会造成函数内判断相等而导致报错。
故保持两个原则：
• 如果两边的值中有 true 或者 false ，千万不要使用 == 。
• 如果两边的值中有 [] 、 "" 或者 0 ，尽量不要使用 == 。
这时最好用 === 来避免不经意的强制类型转换。
