javaScript 基础学习篇 之数据类型转换

1. 强制转换

Number() 将任意值转换为数值

a.原始类型值

// 数值：转换后还是原来的值
Number(324) // 324

// 字符串：如果可以被解析为数值，则转换为相应的数值
Number('324') // 324

// 字符串：如果不可以被解析为数值，返回 NaN
Number('324abc') // NaN

// 空字符串转为0
Number('') // 0

// 布尔值：true 转成 1，false 转成 0
Number(true) // 1
Number(false) // 0

// undefined：转成 NaN
Number(undefined) // NaN

// null：转成0
Number(null) // 0

Number将字符串转换为数值时比parseInt要严格，只要有一个字符无法转为数值，则整个字符串就会转为NaN。

parseInt('42 cats') // 42
Number('42 cats') // NaN

Number 和parseInt都会过滤字符串前导和后缀的空格

parseInt('\t\v\r12.34\n') // 12
Number('\t\v\r12.34\n') // 12.34

b.对象

简单的规则是，number方法的参数是对象时，会返回为NaN，除非是包含单个数值的数组。

Number({a: 1}) // NaN
Number([1, 2, 3]) // NaN
Number([5]) // 5

Number背后的转换规则：

第一步是调用对象自身的ValueOf方法，如果返回原始类型的值，则直接对该值使用Number函数，不再进行后续步骤。

第二步如果ValueOf返回的还是对象，则改为调用对象自身的toString方法。如果toString返回的是原始类型的值，则对该值使用Number函数，不再继续后续步骤。

第三步，如果toString返回的是对象，则报错。

var obj = {x: 1};
Number(obj) // NaN

// 等同于
if (typeof obj.valueOf() === 'object') {
  Number(obj.toString());
} else {
  Number(obj.valueOf());
}

obj.valueOf()返回对象本身，再调用toString方法返回[object Object]字符串，再使用Number方法得到NaN。（默认情况下，对象的valueOf方法会返回对象本身）

如果toString()方法返回的不是原始类型的值，就会报错

var obj = {
  valueOf: function () {
    return {};
  },
  toString: function () {
    return {};
  }
};

Number(obj)
// TypeError: Cannot convert object to primitive value

自定义valueOf方法和toString方法

Number({
  valueOf: function () {
    return 2;
  }
})
// 2

Number({
  toString: function () {
    return 3;
  }
})
// 3

Number({
  valueOf: function () {
    return 2;
  },
  toString: function () {
    return 3;
  }
})
// 2

String()将任意值转换为字符串

规则如下：

a.原始类型值

String(123) // "123"
String('abc') // "abc"
String(true) // "true"
String(false) // "false"
String(undefined) // "undefined"
String(null) // "null"

b.对象

String方法的参数如果是对象，则返回一个类型字符串。如果是数组，则返回该数组的字符串形式。

String({a: 1}) // "[object Object]"
String([1, 2, 3]) // "1,2,3"

转换规则与Number方法类似：

第一步调用对象自身的toString()方法，如果返回原始类型的值，则对该值使用String方法，不再继续以下步骤

第二步，如果toString()返回的是对象，则再调用该对象的valueOf方法，如果valueOf方法返回的是原始数据类型的值，则对该值使用String函数，不再继续进行以下步骤。

第三步，如果valueOf返回的是对象，则报错。

String({a: 1})
// "[object Object]"

// 等同于
String({a: 1}.toString())
// "[object Object]"

var obj = {
  valueOf: function () {
    return {};
  },
  toString: function () {
    return {};
  }
};

String(obj)
// TypeError: Cannot convert object to primitive value

自定义toString

String({
  toString: function () {
    return 3;
  }
})
// "3"

String({
  valueOf: function () {
    return 2;
  }
})
// "[object Object]"

String({
  valueOf: function () {
    return 2;
  },
  toString: function () {
    return 3;
  }
})
// "3"

Boolean() 将任意值转为布尔值

除了以下值为false，其他为true

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean(NaN) // false
Boolean('') // false

Boolean({}) // true
Boolean([]) // true
Boolean(new Boolean(false)) // true

2.自动转换

以强制转换为基础

以下三种情况,JavaScript会自动转换数据类型，转换时自动完成的，用户不可见。

第一种情况，不同类型的数据互相运算。

123 + 'abc' // "123abc"

第二种情况，对非布尔值的数据求布尔值

if ('abc') {
  console.log('hello')
}  // "hello"

第三种情况，对非数值类型的值使用一元运算符(+或者-)

+ {foo: 'bar'} // NaN
- [1, 2, 3] // NaN

规则是：预期什么样的值，则调用该类型的转换函数。比如，在某个位置预期为字符串，就调用String函数转换。如果该位置可以是字符串，可以是数值，则默认转为数值。

a.自动转换为布尔值，内部调用Boolean函数

if ( !undefined
  && !null
  && !0
  && !NaN
  && !''
) {
  console.log('true');
} // true

// 写法一
expression ? true : false

// 写法二
!! expression

b.自动转换为字符串

具体规则是先将复合类型的值转为原始类型的值，再讲原始值转为字符串。主要发生在字符串的加法运算，当一个字符串加另一个非字符串时，后者转换为字符串。

'5' + 1 // '51'
'5' + true // "5true"
'5' + false // "5false"
'5' + {} // "5[object Object]"
'5' + [] // "5"
'5' + function (){} // "5function (){}"
'5' + undefined // "5undefined"
'5' + null // "5null"

容易出错的地方：

var obj = {
  width: '100'
};

obj.width + 20 // "10020"

c.自动转换为数值

除了加法运算符有可能会把运算子转为字符串以外，其他的运算符都会把运算子自动转为数值。

'5' - '2' // 3
'5' * '2' // 10
true - 1  // 0
false - 1 // -1
'1' - 1   // 0
'5' * []    // 0
false / '5' // 0
'abc' - 1   // NaN
null + 1 // 1
undefined + 1 // NaN

注意，null转为数值时是0，undefined为NaN.

一元运算符也会把运算子转为数值

+'abc' // NaN
-'abc' // NaN
+true // 1
-false // 0

参考教程：javascript标准参考教程(alpha)