原始值转原始值

number

  • Number()
    • Number(null) == 0 / Number(undefined) == NaN
      两个特例：null == undefined, NaN != NaN
    • Number(Infinity) == Infinity, Number(1) == 1
    • Number(true) == 1 / Number(false) == 0

对于字符串转换

  • Number("1") == 1 / parseInt("1") == 1 / Number("") == 0
  • Number("1.567") == 1.567 / parseInt("1.567") == 1 / parseFloat("1.567") == 1.567
  • Number("0b10") == 2 / parseInt("10", 2) == 2
    Number("0o10") == 8 / parseInt("10", 8) == 8
    Number("0x10") == 16 / parseInt("10", 16) == 16
    Number("010") == 2 / parseInt("010") == 2
  • Number("-123abc") == NaN / parseInt("-123abc") == -123

    Boolean

    除了虚值 falsy 外，所有 Boolean() 都为 true
    falsy 值 Boolean() 都为 false, 这些值有：
  • null
  • undefine
  • false
  • ‘’、””、’’ 空字符串
  • 0、+0/-0、0n
  • NaN

    String

    调用原始值包装类的 toString() 方法，null undefined 为 “null” “undefined”

    加号 + 是运算符号，还是字符串连接符号

    左右两边为 number 或 boolean 是运算符号，否则是字符串连接符号

:::info 所有引用值在隐式转换时都会转为原始值 :::

对象转 Boolean

除了 falsy，都有 Boolean 都为 true, 所以 Boolean({})、Boolean([]) 都为 true

对象转 Number

对象转 String

隐式转换触发条件

触发转 Number的条件

运算符号 +、-、*、/、%
位运算 ~、&、|、^、<<、>>、>>>
判断 ==、!=、>=、<=、<、>

触发转 Boolean 的条件

if、while、for、!、?:、&&、||
switch 是不会触发隐式转换

触发转 String 的条件

字符串连接符号 +

题目

  1. []+[]

这个加号左右两都不 number 所以是字符串连接符号。
那么两边都要作 String([]) 转为字符串，[].toString 为调用原型上 Array.prototype.toString 的方法，其操作的行为是相当于把 [] 去掉，然后把内面的内容以 string 来显示。所以 [] 是 ‘’ 空串。
最终结果就是 ‘’ + ‘’ == ‘’，空串连接空串就是空串。

  1. []+{}

与上一题相似，加号也是字符串连接符号。
[].toString 为 ‘’ 空串；
{}.toString 调用 原型上 Object.prototype.toString 的方法，返回字符串 ‘[object Object]’;
最终结果就是 ‘’ + ‘[object Object]’ == ‘[object Object]’。

  1. {}+[]

这题 {} 在这个位置不是对象，而是表示块，不用理会（如要有表示对象，应该用 () 进行包裹，({})）。
所以可以看成 +[]，那么加号是运算符号的 +。
那么 [] 要转为 number，[].valueOf() 肯定是 [] 非原始值，只看 [].toString() 为空串。空串用 Number 进行包装，Number('') == 0
最终结果就是 +0 == 0。

  1. !+[]+[]+![]

首先 !+[] 最终会转为 boolean，这个加号是运算加。!+Number([])，!+0，!Boolean(0), !false，true；
然后 true+[]，这个加号是字符串连接，true + ‘’，’true’；
'true'+![]，这个加号也是字符串连接，’true’+String(![])，![]，是先转为 boolean，Boolean([]) 为 true, !true 就是 false。即 ![] 为 false。
‘true’+false，最终结果就把两边转为字符串再连接，’truefalse’。

  1. [] == ![]

== 是把两边最终都转为 number 作比较，
Number([])，0
![]，因为有 ! 要先转为 boolean，下一步才转 number

  1. ![] 为 !Boolean([]), Boolean()中非虚值都为 true，所以是 !true, 即 false
  2. 再把 false 转为 Number(false)，即 0

最终比较 0 == 0，结果是 true

  1. {} == !{}

== 是把两边最终都转为 number 作比较
Number({}) {}.toString() 为 ‘[object Object]’，然后 Number(‘[object Object]’)，为 NaN
!{}, 因为有 ! 要先转为 boolean，下一步才转 number

  1. !{} 为 !Boolean({})，Boolean()中非虚值都为 true，所以是 !true, 即 false
  2. 再把 false 转为 Number(false)，即 0

最终比较 NaN == 0，结果是 false