类型转换 盲区

Posted 2021-01-08 ensnail

转 Boolean 

在条件判断时，除了 undefined， null， false， NaN， ‘‘， 0， -0，其他所有值都转为 true，包括所有对象。

对象转基本类型

对象在转换基本类型时，首先会调用 valueOf 然后调用 toString。并且这两个方法是可以重写的。也可以重写 Symbol.toPrimitive ，且该方法在转基本类型时调用优先级最高。 　

let a = {
  valueOf() {
    return 0;
  },
  toString() {
    return ‘1‘;
  },
  [Symbol.toPrimitive]() {
    return 2;
  }
}
1 + a // 3
‘1‘ + a // ‘12‘

Number({}) // NaN
({}).valueOf() // {}
({}).toString() // ‘[object Object]‘ NaN

Number([]) // 0
[].valueOf() // []
[].toString() // ‘‘

[1].valueOf() // [1]
[1].toString() // ‘1‘

[1,2].valueOf() // [1,2]
[1,2].valueOf() // ‘1,2‘

Number(function(){}) // NaN
(function () {}).valueOf() // f(){}
(function () {}).toString() // ‘function () {}‘

 

数字转换

parseInt 在转换数字时会向下取整，损失精度。Number 和 parseFloat 转换结果不变。

在转换数字时，如果数字是以 0 开头，那么将数字转换为 8进制，如果数字是以 0x 开头的，那么将数字转换为 16 进制。

Number(3.1415926) // 3.1415926
parseInt(3.1415926) // 3
parseFloat(3.1415926) // 3.1415926

Number(010) // 8
parseInt(010) // 8
parseFloat(010) // 8

Number(0x10) // 16
parseInt(0x10) // 16
parseFloat(0x10) // 16

数字转换字符串

Number 转换字符串时，会把字符串当做一个整体，如果字符串是空的，那么返回 0 ；如果字符串非空，且字符串中有一个字符不是数字，那么转换结果就是 NaN。

parseInt 与 parseFloat 在转换字符串时，会一个字符一个字符的转换，如果字符串开头存在数字，那么返回数字，如果字符串开头不是数字，返回 NaN，点开头的，parseInt 会返回 NaN，而parseFloat 会前添0。

在用parseInt 进行转换时，如果字符串是以 ox 开头的数字，那么将字符串转换为 16 进制。

字符串数字，转换时，会自动前后处理小数的0。正负数能正常转换。

Number(‘‘) // 0
parseInt(‘‘) // NaN
parseFloat(‘‘) // NaN

Number(‘Hello 123‘) // NaN
parseInt(‘Hello 123‘) // NaN
parseFloat(‘Hello 123‘) // NaN

Number(‘123 Hello‘) // NaN
parseInt(‘123 Hello‘) // 123
parseFloat(‘123 Hello‘) // 123

Number(‘.123‘) // 0.123
Number(‘123.900‘) // 123.9
Number(‘00.123‘) // 0.123
Number(‘+123‘) // 123
Number(‘-123‘) // -123

parseInt(‘.123‘) // NaN
parseInt(‘123.900‘) // 123
parseInt(‘00.123‘) // 0
parseInt(‘+123‘) // 123
parseInt(‘-123‘) // -123

parseFloat(‘.123‘) // 0.123
parseFloat(‘123.900‘) // 123.9
parseFloat(‘00.123‘) // 0.123
parseFloat(‘+123‘) // 123
parseFloat(‘-123‘) // -123

parseInt(‘0x0010Hellow‘)  // 16
parseFloat(‘0x0010Hellow‘) // 0

parseInt(‘010Hellow‘) // 10
parseFloat(‘010Hellow‘) // 10

数字转Boolean

Number 在转换布尔值时，如果布尔值为 true 返回 1， 否则返回 0；

parseInt 与 parseFloat 转换布尔值总是返回 NaN。

Number(true) // 1         
parseInt(true) // NaN    
parseFloat(true) // NaN        

Number(false) // 0
parseInt(false) // NaN    
parseFloat(false) // NaN

数字转null

Number 转 null 值为 0，而 parseInt 与 parseFloat 转 null 的值为 NaN。

Number(null) // 0         
parseInt(null) // NaN    
parseFloat(null) // NaN

数字转undefined

Number、parseInt、parseFloat 转 undefined 的值为 NaN。

Number(undefined) // NaN
parseInt(undefined) // NaN
parseFloat(undefined) // NaN

 

总结：

1. parseInt 与 parseFloat 只能转换数字或者以数字开头的字符串，其他全部为 NaN。parseFloat能转换以 点 开头后面跟数字的字符串。

2. Number 转换数字或数字字符串时，如果字符串中含有除数字之外的其他字符，返回NaN。转换null、‘’、false、[] 时返回 0 ，true、[1] 返回 1，其他返回 NaN。

隐式转换

一元运算符 + 与 - 可以将其他类型的值转换为数字，- 转换结果为负数。转换规则与 Number 相同。

+ 3.14 // 3.14
- 3.14 // -3.14

+ ‘‘ // 0
- ‘‘ // -0

+ ‘hello‘ // NaN
- ‘hello‘ // NaN

+ true // 1
- true // -1

+ false // 0
- false // -0

+ null // 0
- null // -0

+ undefined // NaN
- undefined // NaN

+ {} // NaN
- {} // NaN

+ [] // 0
- [] // -0

+ [1] // 1
- [1] // -1

+ [1,2] // NaN
- [1, 2] // NaN

+ (function(){}) // NaN
- (function(){}) // NaN

一元运算符 ！取反

! null // true
! ‘‘ // true
! undefined // true
! 0 // true
! -0 // true
! NaN // true

// 其他都为false

+ 运算符 中含对象

{} + [] // {}; +[] = +0 = 0
({}) + [] // ‘[object Object]‘ + ‘‘ = ‘[object Object]‘

相等运算符，原始类型与复合类型比较时，会将复合类型转换成对应的原始类型

[1] == 1 // Number([1]) == 1  true
[1] == ‘1‘ // String([1]) == Number(‘1‘)  true
[1] == true // Boolean([1]) == true true

 题目

0 == null // false
0 > null // false
0 >= null // true ?

第一行，0 == null、undefined、{} 、ture 、function () {} 都为 false，0 == ‘’、[]、false 为true

第二行，没有字符串，转换为数字，0 > Number(null)，0 > 0 ，false

第三行，没有字符串，转换为数字，0 >= Number(null)，0 >= 0 ，true

 

~~运算符，连续使用两个否运算符，进行向下取整，这是所有取整方法中最快的一种。

~~3.1415 // 3
~~3.64 // 3

^ 异或运算符，常用于不借助第三方变量，交换两个变量的值。

var a = 9
var b = 5

a = a ^ b
b = a ^ b
a = a ^ b

console.log(a, b) // 5 9