一、其它类型转换成Number类型

1. 通过 Number()、parseInt()、parseFloat()将非数值类型转换为数值类型

Number()是转型函数，可用于任何数据类型。后两个函数主要将字符串转为数值。
parseInt()从第一个非空字符开始转换，第一个字符不是数值字符、加号或减号就会立即返回NaN，这意味着空串也会返回NaN，而Number()会返回0

Number()转换规则
1）数值转成数值
直接返回

  1. Number(Infinity) => Infinity
  2. Number(NaN) => NaN

2）字符串转成数值

  1. Number("") => 0
  2. Number("  ") => 0
  3. Number("\t") => 0
  4. Number("\n") => 0
  5. Number("123") => 123
  6. Number("1.23") => 1.23
  7. Number("123n") => NaN

3）布尔值转成数值

  1. Number(true) => 1
  2. Number(false) => 0

4）undefined、null转换成数值

  1. Number(undefined) => NaN
  2. Number(null) => 0

5）对象转换成数值

  1. 先调用valueOf()方法，并按照上述规则转换返回的值。
  2. 如果转换是NaN，则调用toString()方法，在按照上述规则转换返回的值
  4. const test = {foo:1}
  6. console.log(Number(test)) // NaN 
  8. 转换步骤
  9. 1. 调用valueOf() => {foo:1} 用Number()转换后为NaN
  10. 2. 调用toString() => "[object Object]" 用Number()转换后为NaN
  12. !!!注意：当调用toString()的时候 是调用该类型原型上的toString()方法
  13. 若 test = [1,2] 则用Number()转换时，调用toString()的时候调用的是Array.prototype.toString.call()
  14. Array.prototype.toString.call([1,2]) => "1,2" 相当于将[]剥去
  16. *************************************
  18. Object.prototype.toString.call()
  19. Number.prototype.toString.call() // 只能 Number类型 转化为 string
  20. String.prototype.toString.call() // 只能 String类型 转化为 string
  21. Boolean.prototype.toString.call()    // 只能 Boolean类型 转化为 string
  23. xxx.prototype.toString.call() // 除了Object，其它类型都是只能将自己本身类型的值转化为string

2. 有数学运算符的时候 +、-、*、/、%

会隐式的将非数值类型用Number()进行包裹按照Number()的规则进行转换

3. “==”相等运算符比较时，有时也会将其它类型转换成数值

二、其它类型转换成Boolean类型

1. 通过Boolean()进行转换

Boolean()转换规则
除了 falsey(虚值)：undefined、null、0、NaN、false、”” 会转为false，其它全为true

  1. console.log(Boolean(undefined)) // false
  2. console.log(Boolean(null)) // false
  3. console.log(Boolean(0)) // false
  4. console.log(Boolean(NaN)) // false
  5. console.log(Boolean(false)) // false
  6. console.log(Boolean('')) // false
  8. console.log(Boolean(Infinity)) // true
  9. console.log(Boolean([])) // true
  10. console.log(Boolean({})) // true

2. 通过 !、!!进行转换

会隐式地将非布尔类型用Boolean()包裹然后按上述规则进行转换，最后按!、!!进行相应的取反、转换操作

3. 条件判断中的条件最终都会转为布尔类型进行比较

三、其它类型转换成String类型

1. 通过toString()方法转换

undefined、null 没有toString()方法，需通过String()去获取对应的字符串
1）当原始值调用toString()方法
会使用相应的包装类去包装原始值，然后调用包装类上的toString()方法
当数值调用toString()方法时，可以传入参数表示用什么底数来输出该数值的字符串

  1. let num = 10
  2. num.toString(2) => "1010"
  3. num.toString(8) => "12"
  4. num.toString(10) => "10"
  5. num.toString(16) => "a"

2）当对象调用toString()方法
会调用该对象原型上的toString()方法

2. 通过String()方法转换

String()转换规则
1）对应值有toString()方法，则调用toString()方法
2）undefined、null 转成字符串

  1. String(undefined) => "undefined"
  2. String(null) => "null"
  4. 解释：因为undefined、null没有toString()方法，则调用valueOf()方法，将返回值以字符串形式输出，
  5. 也就是直接返回本身字面量文本

3）对象转成字符串
先调用原型上toString()方法，如果toString()返回值不为原始值，则调用valueOf()方法将返回值按String()规则进行转换

3. 通过 “+” 进行字符串拼接

当表达式中出现字符串就是字符串拼接，会将非字符串类型以String()进行包裹，然后按照规则进行转换再进行拼接

!!!特殊：引用类型 + 数字 时，首先会调用引用类型的toString()转换成字符串，再变成字符串拼接

  1. {} + 1 => "[object Object]1"
  2. [1,2] + 1 => "1,21"

4. 给对象设置属性，如果属性名不是字符串，首先转换为字符串，然后再当作属性存储到对象中

5. 基于alert/confirm/prompt/document.write等方法输出内容的时候，会把输出的值转换为字符串，然后再输出

四、详解“==”等于运算符

“==”与“===”不同，“==”会尝试将不同类型转换成相同类型，然后再进行比较；而“===”不会尝试进行类型转换，如果类型不相同那么就视为不同

对象 == 对象
当同时引用同一个对象(地址空间)时，才返回true

undefined == null
!!!特殊 返回true，undefined和null只有在它们俩比较时才为true，它们俩比较其它都为false

数字 == 字符串
将字符串转换成数值，再进行比较

数字 == 布尔值
将布尔值转换成数值，再进行比较

数字 == 对象
使用对象的valueOf()和toString()方法将对象转为原始值，再将原始值转换成数值，再进行比较

字符串 == 对象
都转换为数值，再进行比较

布尔值 == 对象
都转换为数值，再进行比较

字符串 == 布尔值
都转换为数值，再进行比较

NaN == 任何
NaN与本身和其它都不相同，都返回false

五、对 [] ==![] 、{} ==!{}详解

  1. [] == ![] // true
  3. 1. 先对 “==” 两边求值，右边做的是一个布尔值的转换则 [] == false
  4. 2. 将左右两边都转换成数值类型 左边 [] 调用 toString() 变为 ""，再转换为数值 0
  5.    [] => "" => 0，右边 false 转换成数值类型 false => 0
  6. 3. 最终 [] == ![] => "" == false => 0 == 0 => true
  8. {} == !{} // false
  10. 1. 先对两边求值，{} == false
  11. 2. 将两边转换成数值类型，左边 {} 调用 toString() 变为 [object Object]，再转换成数值 NaN
  12.    右边 false 转换成数值类型 false => 0
  13. 3. 最终 {} == !{} => NaN == false ==> NaN == 0 => false