隐式转换

1. 对象的隐式转换

   var a = {
     valueOf() {
       return 1;
     },
     toString() {
       return '2';
     }
   }
   
   a == 1 // true
   a === 1 // false
   a == '2' // false
   a === '2' // false
   
   Number(a) === 1  // true
   String(a) === '2' // true
   
   var b = { valueOf() { return 1; } }
   var c = { toString() { return '2'; } }
   
   Number(c) // 2
   String(b) // "[object Object]"
   

   对普通对象来说，除非自行定义，否则toString()（Object.prototype.toString()）返回内部属性[[Class]]的值，如“[object Object]”。

   数组的默认toString()方法经过了重新定义，将所有单元字符串化以后再用“，”连接起来

   var a = [1,2,3];
   a.toString(); // "1,2,3"
   

2. JSON.stringify() 在将JSON对象序列化为字符串时也用到了ToString

   JSON.stringify( 42 ); // "42"
   JSON.stringify( "42" ); // ""42"" （含有双引号的字符串）
   JSON.stringify( null ); // "null"
   JSON.stringify( true ); // "true"
   

   JSON.stringify(..)在对象中遇到undefined、function和symbol时会自动将其忽略，在数组中则会返回null（以保证单元位置不变）。

   (1)字符串、数字、布尔值和null的JSON.stringify(..)规则与ToString基本相同。

   (2)如果传递给JSON.stringify(..)的对象中定义了toJSON()方法，那么该方法会在字符串化前调用，以便将对象转化为安全的JSON值。

3. parseInt

   parseInt( 1/0, 19 ); // 18 来自于N
   
   parseInt( 0.0000008 ); // 8 ("8" 来自于 "8e-7")
   
   parseInt( parseInt, 16 ); // 15 ("f" 来自于 "function..")
   
   parseInt( "0x10" ); // 16
   parseInt( "103", 2 ); // 2
   

4. 假值的相等情况

   // null 只与 undefined相等
   "0" == null; // false
   "0" == undefined; // false
   "0" == false; // true -- 晕！
   
   // NaN与任何都不相等
   "0" == NaN; // false
   "0" == 0; // true
   "0" == ""; // false
   
   false == null; // false
   false == undefined; // false
   
   false == NaN; // false
   
   // Number(false) === 0
   false == 0; // true -- 晕！
   
   // Number('') ===0
   false == ""; // true -- 晕！
   // Number([]) ===0
   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
   
   2 == [2]; // true
   "" == [null]; // true
   0 == "\n"; // true
   42 == "43"; // false
   "foo" == 42; // false
   "true" == true; // false
   42 == "42"; // true
   "foo" == [ "foo" ]; // true
   

5. 终端情况

   [] == ![] // true
   
   // 分析
   Number([]) === 0
   ![] === false
   
   0 == false // true
   

6. 完整性检查

   "0" == false; // true
   false == 0; // true
   false == ""; // true
   false == []; // true
   "" == 0; // true
   "" == []; // true
   0 == []; // true
   

7. 抽象关系比较

   • a < b中涉及的隐式强制类型转换不太引人注意，不过还是很有必要深入了解一下。
     比较双方首先调用ToPrimitive，如果结果出现非字符串，就根据ToNumber规则将双方强制类型转换为数字来进行比较。
   • 如果比较双方都是字符串，则按字母顺序来进行比较：

   var a = { b: 42 };
   var b = { b: 43 };
   a < b; // false
   a == b; // false
   a > b; // false
   a <= b; // true
   a >= b; // true
   
   // 因为a是[object Object]，b也是[object Object]，所以按照字母顺序a<b并不成立。
   

隐式转换规则

1. 对于严格相等 ===

如果Type(x)和Type(y)不同，返回false
如果Type(x)和Type(y)相同
如果Type(x)是Undefined，返回true
如果Type(x)是Null，返回true
如果Type(x)是String，当且仅当x,y字符序列完全相同（长度相同，每个位置上的字符也相同）时返回true，否则返回false
如果Type(x)是Boolean，如果x,y都是true或x,y都是false返回true，否则返回false
如果Type(x)是Symbol，如果x,y是相同的Symbol值，返回true,否则返回false
如果Type(x)是Number类型
如果x是NaN，返回false
如果y是NaN，返回false
如果x的数字值和y相等，返回true
如果x是+0，y是-0，返回true
如果x是-0，y是+0，返回true
其他返回false

2. 对于 ==

如果Type(x)和Type(y)相同，返回x===y的结果
如果Type(x)和Type(y)不同
如果x是null，y是undefined，返回true
如果x是undefined，y是null，返回true
如果Type(x)是Number，Type(y)是String，返回 x==ToNumber(y) 的结果
如果Type(x)是String，Type(y)是Number，返回 ToNumber(x)==y 的结果
如果Type(x)是Boolean，返回 ToNumber(x)==y 的结果
如果Type(y)是Boolean，返回 x==ToNumber(y) 的结果
如果Type(x)是String或Number或Symbol中的一种并且Type(y)是Object，返回 x==ToPrimitive(y) 的结果
如果Type(x)是Object并且Type(y)是String或Number或Symbol中的一种，返回 ToPrimitive(x)==y 的结果
其他返回false