== 和 ===区别

== 允许再相等比较中进行强制类型转换，而 === 不允许

两者都会比较类型和值

而==遇到类型不一致时，会进行类型转换

===

• 不同类型，返回false
• 同类型
  • 引用类型比较引用地址
  • 原始类型比较值
  • NaN 不等于 NaN
  • +0 等于 -0

==

• 同类型（同 ===）
  • 引用类型比较引用地址
  • 原始类型比较值
  • NaN 不等于 NaN
  • +0 等于 -0
• 不同类型
  • null 和 undefined // true
  • 数字与字符串 // ToNumber
  • 布尔值与其他值 // ToNumber
  • 对象与非对象 // ToPrimitive

注意 null 和 undefined 除了自身的这两个类型之外，不等于任何其他类型 所以一看到 null 和 undefined，要警惕

ToNumber

类型	ToNumber后
true	1
false	0
null	0
undefined	NaN
String	先看看是否包含数字字面量，否则返回NaN
Object	先toPrimitive，最后ToNumber

注意 String 会先看看是数字字面量，否则返回NaN undefined 会返回 NaN

ToString

类型	ToString后
null	'null'
undefined	'undefined'
Boolean	'true'/'false'
Number	'1'/科学计数法
Object	除非自定义（例如Array,BigInt），否则调用toString()，返回[[Class]]("[Object XXX]")

ToBoolean

为false的值

• false
• +0，-0
• NaN
• null
• undefined
• ""

除了为false的值，都为true

ToPrimitive

类型转换有三种变体，它们被称为“hint”;

• string
• number
• default

toPrimitive 会进行

为了进行转换，JavaScript 尝试查找并调用三个对象方法：

1. 调用 obj[Symbol.toPrimitive](hint) —— 带有 symbol 键 Symbol.toPrimitive（系统 symbol）的方法，如果这个方法存在的话，
2. 否则，如果 hint 是 "string" —— 尝试调用 obj.toString() 或 obj.valueOf()，无论哪个存在。
3. 否则，如果 hint 是 "number" 或 "default" —— 尝试调用 obj.valueOf() 或 obj.toString()，无论哪个存在。

面试题

诀窍

1. 类型是否相同
2. NaN不等于任何数，包括自身
3. null 和 undefined 互等，（null,undefined）之外不等于其他类型
4. 对象，toPrimitive
5. 其他类型，toNumber

"0" == null; // null 除（null,undefined）不等于其他的类型 false
"0" == undefined; // undefined 除（null,undefined）不等于其他的类型 false
"0" == false; // toNumber 0 == 0 true
"0" == NaN; // NaN false
"0" == 0; // toNumber 0 == 0 true
"0" == ""; // 注意，同类型，直接比较值 false


false == null; // false
false == undefined; // false
false == NaN; // false
false == 0; // toNumber 0 == 0 true
false == ""; // toNumber 0 == 0 true
false == []; //  0 == '' 0 == 0 true
false == {}; // 0 == "[object Object]" 0 == NaN false


"" == null; // false
"" == undefined; // false 
"" == NaN; // false
"" == 0; // toNumebr 0 == 0 true
"" == []; //  "" == "" true
"" == {}; //  "" == "[object Object]" false


0 == null; // false
0 == undefined; // false
0 == NaN; // false
0 == []; // 0 == "" 0 == 0 true
0 == {}; // 0 == "[object Object]" 0 == NaN false


[] == ![] // [] == !("") [] == true "" == true 0 == 1 false
2 == [2] // 2 == '2'  2 == 2 true
"" == [null]; // "" == "" true


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

总结一下

1. ==和===都会比较类型，==会类型强制转换
2. ==的诀窍
   1. NaN直接等于false
   2. null undefined不等于除自身之外（null, undefined）的任何类型
   3. 相同类型的，比较值
   4. 对象，toPrimitive
   5. 其他类型，toNumber