JavaScript中通常分为两种类型转换，“隐式强制类型转换”（implicit coercion）和“显式强制类型转换”（explicit coercion）。

下面所有代码的源码可以在此处查看。

一、强制转换为字符串（ToString）

1）ToString

基本类型值的字符串化规则为：null转换为"null"，undefined转换为"undefined"，true转换为"true"。数字的字符串化则遵循通用规则，不过那些极小和极大的数字使用指数形式：

// 1.07 连续乘以七个 1000
var a = 1.07 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000;
// 七个1000一共21位数字
console.log(a.toString()); // "1.07e21"

对普通对象来说，除非自行定义，否则toString()（Object.prototype.toString()）返回内部属性[[Class]]的值

2）JSON

JSON.stringify(..)在对象中遇到undefined、function和symbol时会自动将其忽略，在数组中则会返回null（以保证单元位置不变）。

如果对象中定义了toJSON()方法，JSON字符串化时会首先调用该方法，然后用它的返回值来进行序列化。

JSON.stringify(undefined); // undefined
JSON.stringify(function() {}); // undefined

JSON.stringify(
  [1, undefined, function() {}, 4]
); // "[1,null,null,4]"
JSON.stringify({
    a: 2,
    b: function() {}
}) // "{"a":2}"

二、强制转换数字（ToNumber）

1）ToNumber

1. true转换为1，false转换为0；

2. undefined转换为NaN，null转换为0；

3. ""，[]转换为0。处理失败时返回NaN。

4. ToNumber对以0开头的十六进制数并不按十六进制处理。

2）对象

对象（包括数组）会首先被转换为相应的基本类型值，如果返回的是非数字的基本类型值，则再遵循以上规则将其强制转换为数字。

为了将值转换为相应的基本类型值，抽象操作ToPrimitive会首先（通过内部操作DefaultValue）检查该值是否有valueOf()方法。

如果有并且返回基本类型值，就使用该值进行强制类型转换。如果没有就使用toString()的返回值（如果存在）来进行强制类型转换。

var a = {
  valueOf: function() { //先执行valueOf
    return "42";
  }
};
var b = {
  toString: function() { //再执行toString
    return "42";
  }
};
var c = [4, 2];
c.toString = function() {
  return this.join(""); // "42"
};
Number(a); // 42
Number(b); // 42
Number(c); // 42
Number(""); // 0
Number([]); // 0
Number(["abc"]); // NaN

三、强制转换布尔值（ToBoolean）

1）假值（falsy value）

可强制类型转换为false。包括undefined、null、false、+0、-0、NaN、""。

undefined、null、false、+0、-0、NaN、""

2）真值

[]、{}和function(){}都不在假值列表中。

[]、{}和function(){}

四、显式强制类型转换

1）奇特的~运算符

~x大致等同于-(x+1)。

~42;    // -(42+1) ==> -43

用~~来截除数字值的小数部分~~中的第一个~执行ToInt32并反转字位，然后第二个~再进行一次字位反转，即将所有字位反转回原值，最后得到的仍然是ToInt32的结果。

//奇特的~
var a = "Hello World";
if (~a.indexOf("lo")) { //如果未找到就返回-1，(-1+1)=0就是false 
  // 找到匹配！ 
}

//~~
Math.floor(-49.6); // -50
~~-49.6; // -49

2）显式解析数字字符串

解析允许字符串中含有非数字字符，解析按从左到右的顺序，如果遇到非数字字符就停止。

转换不允许出现非数字字符，否则会失败并返回NaN。

var a = "42";
var b = "42px";
Number(a); // 42
parseInt(a); // 42

Number(b); // NaN
parseInt(b); // 42

解析字符串中的浮点数可以使用 parseFloat(..) 函数。

非字符串参数会首先被强制类型转换为字符串（执行toString方法）。

parseInt(0.000008); // 0 ("0" 来自于 "0.000008")
parseInt(0.0000008); // 8 ("8" 来自于 "8e-7") 
parseInt(false, 16); // 250 ("fa" 来自于 "false") 
parseInt(parseInt, 16); // 15 ("f" 来自于 "function..")

parseInt("0x10"); // 16 
parseInt("103", 2); // 2

五、隐式强制类型

1）字符串和数字之间的隐式强制类型转换

如果+其中一个操作数是字符串则执行字符串拼接；否则执行数字加法。

如果其中一个操作数是对象（包括数组），则对其调用 ToPrimitive 抽象操作。

var a = "42";
var b = "0";
a + b; // "420" 两个都是字符串
var c = 42;
var d = 0;
c + d; // 42 两个都是数字
var a = [1, 2];
var b = [3, 4];
a + b; // "1,23,4" 两个都是对象

2）隐式强制类型转换为布尔值

以下情况，非布尔值会被隐式强制类型转换为布尔值，遵循ToBoolean 抽象操作规则。

1. if (..)语句中的条件判断表达式。

2. for ( .. ; .. ; .. )语句中的条件判断表达式（第二个）。

3. while (..)和do..while(..)循环中的条件判断表达式。

4. ? :中的条件判断表达式。

5. 逻辑运算符||（逻辑或）和&&（逻辑与）左边的操作数（作为条件判断表达式）。

六、宽松相等和严格相等

常见的误区是“ == 检查值是否相等， === 检查值和类型是否相等”。听起来蛮有道理，然而还不够准确。

正确的解释是：“ == 允许在相等比较中进行强制类型转换，而 === 不允许”

1）字符串和数字之间的相等比较

1.如果 Type(x) 是数字， Type(y) 是字符串，则返回 x == ToNumber(y) 的结果。

2.如果 Type(x) 是字符串， Type(y) 是数字，则返回 ToNumber(x) == y 的结果。

2）其他类型和布尔类型之间的相等比较

1.如果 Type(x) 是布尔类型，则返回 ToNumber(x) == y 的结果。

2.如果 Type(y) 是布尔类型，则返回 x == ToNumber(y) 的结果。

3）null 和 undefined 之间的相等比较

1.如果 x 为 null ， y 为 undefined ，则结果为 true 。

2.如果 x 为 undefined ， y 为 null ，则结果为 true 。

4）对象和非对象之间的相等比较

1.如果 Type(x) 是字符串或数字， Type(y) 是对象，则返回 x == ToPrimitive(y) 的结果。

2.如果 Type(x) 是对象， Type(y) 是字符串或数字，则返回 ToPromitive(x) == y 的结果。

var a = "abc";
var b = Object(a); // 和new String( a )一样
a === b; // false 
//b 通过 ToPromitive 进行强制类型转换（也称为“拆封”，unboxed或者unwrapped） ，并返回标量基本类型值 "abc" ，与 a 相等。
a == b; // true

//null和undefined不能够被封装（boxed），Object(null)和 Object(undefined) 均返回一个常规对象。
var a = null;
var b = Object(a); // 和Object()一样
a == b; // false

var c = undefined;
var d = Object(c); // 和Object()一样
c == d; // false
//NaN能够被封装为数字封装对象，但NaN不等于NaN
var e = NaN;
var f = Object(e); // 和new Number( e )一样
e == f; // false

5）假值的相等比较

假值，就是上面ToBoolean中提到的假值。

"0" == false;//true 按照2）和1）的规则
false == 0;//true 按照2）的规则
false == "";//true 按照2）和1）的规则
false == [];//true 按照4）2）1）的规则
"" == 0;//true 按照1）
"" == [];//true 按照4）的规则
0 == [];//true 按照4）1）的规则
[] == ![]// true ![]执行后的值是false

6）安全运用隐式强制类型转换

1.如果两边的值中有true或者false，千万不要使用==。

2.如果两边的值中有[]、0或者"" ，尽量不要使用==。

7）比较图表

dorey提供的一张在线图表。

posted on 2017-03-09 11:53 咖啡机（K.F.J）阅读(1016) 评论(0) 编辑收藏举报

刷新页面返回顶部