下面值等于多少以及原理
    1、1 + ‘1’ = ?

    1. 11 // 存在字符串，所以变成连字符

    2、true + 0 = ?

    1. 1 // 先将bool转成数字再相加

    3、{}+[] =？

    1. 0     // 空对象在最前面会被解析为{emptyblock} 空白块，
    2.         // 相当于 {}+[] => +[](数组取正)；数组valueOf 是自身，则使用[].toString() = 0

    4、4 + {} =？

    1. 4[object Object] // 存在空对象，且不是在最前面，所以会执行({}).valueOf,返回的是自身，
    2.                     // 接着取({}).toString(),返回的是 [object Object] 所以是‘4[object Object]’

    5、4 + [1] =？

    1. 41 //[1].valueOf() = [1], 所以继续执行 [1].toString() = '1'

    6、’a’ + + ‘b’=？

    1. aNaN // 优先计算逻辑 + 'b' = NaN （‘+’是一元运算符）；所以是a+ NaN = aNaN
    1. 其中知识点
    3. js运算，加法会进行隐式类型转换，
    4. （1）规则是调用其 valueOf() 或 toString() 以取得一个非对象的值（primitive value）。
    5. （2）如果两个值中的任何一个是字符串，则进行字符串串接，否则进行数字加法
    6. （3）布尔值与数值或布尔值相加，布尔值都会自动转成数值，然后再相加
    7. （4）如果运算子是对象，必须先转成原始类型的值，然后再相加。

    附一张js计算优先级图，方便看
    image.png

    1、console.log ( [] == 0 )

    1. true 
    2. // 左边是[].toString() = ''
    3. // 右边是0
    4. // 比较浅先将bool转成数字，所以是0 == 0 所以 结果是true

    2、console.log ( ! [] == 0 )

    1. true 
    2. // 左边 ![] 其中!可将变量转换成boolean类型，
    3. // 由于 null、undefined、NaN以及空字符串('')取反都为true，其余都为false,所以![] => false 
    4. // 右边是0 ，所以  0 == 0 是true

    3、console.log ( [] == ! [] )

    1. true //  右边存在！，优先预算，![] = false；等式变为[] == false；需要做类型转换成数值
    2.         //  Number([]) == Number(false); 相当于 '' == 0 所以是true

    4、console.log ( [] == [] )

    1. false // 左右类型相同，且不是基本类型，判断指针不是指向同个地方 ，所以是false

    5、console.log({} == !{})

    1. false // 右边出现！，优先执行，!{} = false
    2.             // 左右类型不同需要转化成数值，Number({}) == Number(false) 相当于NaN == 0 所以是false

    6、console.log({} == {})

    1. false // 和[] == [] 道理一样
    1. 知识点
    2. 比较预算中
    3. 如果两个运算子都是原始类型的值，则是先转成数值再比较。
    4. 如果运算子是对象，会转为原始类型的值，再进行比较。
    6. 相等运算符（==）比较两个值是否相等，如果类型不同需要先做基本类型转换
    7. 严格相等运算符（===）比较它们是否为“同一个值”。
    8. 如果两个值不是同一类型，严格相等运算符（===）直接返回false，
    9. 而相等运算符（==）会将它们转换成同一个类型，再用严格相等运算符进行比较。

    参考文献链接