类型转化

转 Boolean

以下都为假值,其他所有值都转为 true,包括所有对象(空对象,空数组也转为真)。

  • false
  • undfined
  • null
  • ''
  • NaN
  • 0
  • -0

对象转基本类型

对象在转换基本类型时,会调用valueOf, 需要转成字符类型时调用toString

var a = {
  valueOf() {
    return 0
  },
  toString() {
    return '1'
  },
}

1 + a // 1
'1'.concat(a) //"11"

也可以重写 Symbol.toPrimitive ,该方法在转基本类型时调用优先级最高Symbol.toPrimitive 指将被调用的指定函数值的属性转换为相对应的原始值。

类型转换

运算中其中一方为字符串,那么就会把另一方也转换为字符串 如果一方不是字符串或者数字,那么会将它转换为数字或者字符串

1 + '1' // '11'
true + true // 2
4 + [1, 2, 3] // "41,2,3"

还需要注意这个表达式'a' + + 'b'

'a' + +'b' // -> "aNaN"

因为 + 'b' 等于 NaN,所以结果为 "aNaN",你可能也会在一些代码中看到过 + '1' 的形式来快速获取 number 类型。

JS 类型转换规则总结

JS 隐射类型转换

{} 等于 true 还是 false

var a = {}

a == true // -> false
a == false // -> false

if (a) {
  console.log('进来') // 会输出
}

因为 a.toString() -> '[object Object]' ,而一个

100 + 问题

'100' + 100 // "100100"

100 + '100' // "100100"

100 + true // 101

100 + false // 100

100 + undefined //NaN

100 + null // 100

parseInt 的坑

parseInt(0.0000001) // 1
parseInt('0.0000001') // 0
parseInt(1000000000000000000000) // 1
parseInt('1000000000000000000000') // 1e+21
;(0.0000001).toString() // "1e-7"

1 与 Number(1)有什么区别

var a = Number(1) // 1
var b = new Number(1) // Number {[[PrimitiveValue]]: 1}
typeof a // number
typeof b // object
a == b // true
  • var a = 1 是一个常量,而 Number(1)是一个函数
  • new Number(1)返回的是一个对象
  • a==b 为 true 是因为所以在求值过程中,总是会强制转为原始数据类型而非对象,例如下面的代码:
typeof 123 // "number"
typeof new Number(123) // "object"
new Number(123) instanceof Number // true
123 === new Number(123) // false

console.log(!!(new Boolean(false))输出什么 [易混淆]

true 布尔的包装对象 Boolean 的对象实例,对象只有在 null 与 undefined 时,才会认定为布尔的 false 值,布尔包装对象本身是个对象,对象->布尔 都是 true,所以 new Boolean(false)其实是布尔的 true,看下面这段代码:

if (new Boolean(false)) {
  alert('true!!')
}

只有使用了 valueOf 后才是真正的转换布尔值,与上面包装对象与原始资料转换说明的相同:

!!new Boolean(false) //true
new Boolean(false).valueOf() //false

Object.prototype.toString

如果是原始类型,他会将原始类型包装为引用类型,然后调用对应方法

function dd() {}
var toString = Object.prototype.toString
toString.call(dd) //[object Function]
toString.call(new Object()) //[object Object]
toString.call(new Array()) //[object Array]
toString.call(new Date()) //[object Date]
toString.call(new String()) //[object String]
toString.call(Math) //[object Math]
toString.call(undefined) //[object Undefined]
toString.call(null) //[object Null]
toString.call(123) //[object Number]
toString.call('abc') //[object String]

obj.toString() 和 Object.prototype.toString.call(obj)

同样是检测对象 obj 调用 toString 方法,obj.toString()的结果和 Object.prototype.toString.call(obj)的结果不一样,这是为什么?

这是因为 toString 为 Object 的原型方法,而 Array ,function 等类型作为 Object 的实例,都重写了 toString 方法。不同的对象类型调用 toString 方法时,根据原型链的知识,调用的是对应的重写之后的 toString 方法(function 类型返回内容为函数体的字符串,Array 类型返回元素组成的字符串.....),而不会去调用 Object 上原型 toString 方法(返回对象的具体类型),所以采用 obj.toString()不能得到其对象类型,只能将 obj 转换为字符串类型;因此,在想要得到对象的具体类型时,应该调用 Object 上原型 toString 方法。

输出以下代码运行结果

1 + "1"

2 * "2"

[1, 2] + [2, 1]

"a" + + "b"
  • 1 + "1"
    • 加性操作符:如果只有一个操作数是字符串,则将另一个操作数转换为字符串,然后再将两个字符串拼接起来
    • 所以值为:“11”
  • 2 * "2"
    • 乘性操作符:如果有一个操作数不是数值,则在后台调用 Number()将其转换为数值
  • [1, 2] + [2, 1]
    • Javascript 中所有对象基本都是先调用 valueOf 方法,如果不是数值,再调用 toString 方法。
    • 所以两个数组对象的 toString 方法相加,值为:"1,22,1"
  • "a" + + "b"
    • 后边的“+”将作为一元操作符,如果操作数是字符串,将调用 Number 方法将该操作数转为数值,如果操作数无法转为数值,则为 NaN。
    • 所以值为:"aNaN"

results matching ""

    No results matching ""