前端JS隐式转换

一、==

1. 对象和字符串对比，对象.toString()变为字符串

var a={ toString(){return ''} }
console.log(a=='') // true

2、不说了，看代码

console.log(null==undefined)  // true 但是和其它值比较不相等
console.log(NaN==NaN)  // false 和自己都不相等，别说其它的了

3、除了以上，剩下都是先转化成数字再做比较

• 对象转数字：先调toString()转为字符串，再用Number()函数转为数字

var a={ toString(){return ''} }
console.log(a==0) // true

var b=[1];
console.log(b==1) // true

• 对象和对象对比不会隐式转换

var a={ toString(){return ''} }
console.log(a==[]) // false

var o1={},o2={};
console.log(o1==o2); // false

var arr1=[],arr2=[];
console.log(arr1==arr2); // false

二、+

• {}+其它：不用考虑{}

// 都转成数字，转不了就是NaN
{}+'' // 0
{}+[] // 0
{}+[1] // 1
{}+[1,2] // NaN
{}+{} // NaN
{a:1}+3 // 3

• []+其它：都转成字符串

[]+1 // "1"
[1]+[1] // "11"

Number()

数值 => 原来的值
字符串 => 如果能被解析为数值，就转成数值，否则得到NaN, 空字符串转为0
         Number('1a') = NaN
         '' = 0
         ' ' = 0
布尔值 => true转成1，false转成0
undefined => NaN
null => 0
Object => 先调用.valueOf(), 如果返回不是原始类型，再调用.toString(),如果还不是原始类型，报错
                            如果是原始类型就调用Number()

String()

true => 'true'
undefined => 'undefined'
null => 'null'
Object => 先调用.toString(), 如果返回不是原始类型，再调用valueOf(),如果还不是原始类型，报错
                            如果是原始类型就调用String()

Boolean()

undefined null 0 -0 +0 NaN '' 全部返回false, 其它返回true

对象会先调用valueOf()、toString()转成字符串

字符串和数字之间

a+b有一个是字符串，可以通过ToPrimitive转成字符串，就会进行字符串拼接

'42'+'0'='420'
'42'+0='420'
42+0='420'

true+1=2
true+'1'='true1'

如果操作的是对象（包括数组），先valueof或者toString()转成基本类型，再运算

1+[1]='11'
[1]+1='11'
1+[1,2]='11,2'

减法运算

减、乘、除都会转成数字再运算

[3]-[1]=2
[3]-['1']=2
'3'-'1'=2

宽松相等

字符串和数字比较

// x是数字，y是字符串
x==ToNumber(y)
// x是字符串，y是数字
ToNumber(x)==y

其它类型与布尔值比较

会把布尔值转成 数字再比较

true==42 // 相当于 1==42

对象和非对象之间

// x是数字或字符串，y是对象
x==toPrimitive(y)
// x对象，y是数字或字符串
toPrimitive(x)==y

[1]==1 // true 相当于 

{}+[]=0 
// {}相当于代码块 然后相当于 +[] ==0