JavaScript中通常分为两种类型转换，“隐式强制类型转换”（implicit coercion）和“显式强制类型转换”（explicit coercion）。
下面所有代码的源码可以。
一、强制转换为字符串（ToString）
1）ToString
基本类型值的字符串化规则为：null转换为"null"，undefined转换为"undefined"，true转换为"true"。数字的字符串化则遵循通用规则，不过那些极小和极大的数字使用指数形式：
// 1.07 连续乘以七个 1000var a = 1.07 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000;// 七个1000一共21位数字console.log(a.toString()); // "1.07e21"
对普通对象来说，除非自行定义，否则toString()（Object.prototype.toString()）返回内部属性[[Class]]的值
2）JSONJSON.stringify(..)在对象中遇到undefined、function和symbol时会自动将其忽略，在数组中则会返回null（以保证单元位置不变）。
如果对象中定义了toJSON()方法，JSON字符串化时会首先调用该方法，然后用它的返回值来进行序列化。
JSON.stringify(undefined); // undefinedJSON.stringify(function() {}); // undefinedJSON.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); // 42Number(b); // 42Number(c); // 42Number(""); // 0Number([]); // 0Number(["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); // 42parseInt(a); // 42Number(b); // NaNparseInt(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; // falsevar c = undefined;var d = Object(c); // 和Object()一样c == d; // false//NaN能够被封装为数字封装对象，但NaN不等于NaNvar 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提供的一张。
