原生函数和强制类型装换
var a = new String("abc"); console.log(typeof a); //是Object，而不是string
使用new String("abc"); 创建的是字符串 abc 的封装对象，而不是基本类型值"abc"。
封装对象
由于基本类型值没有.length和.toString()这样的属性和方法，需要通过封装对象才能访问，此时JavaScript会自动为基本类型值包装一个封装对象,如：
var a = "abc"; console.log(a.length);
注意：如果需要频繁的用到.length这样的属性和方法，那么从一开始就创建一个封装对象也许更方便，但需要注意的是，事实并非如此，因为浏览器已经为这些常用的方法做了性能优化。直接使用封装对象来提前优化，反而会降低执行效率。
var a = new Boolean(false); if (!a) { console.log("aaaa"); //永远不会执行到这里 }
为false创建一个封装对象，然而该对象的真是是truthy，所有总是返回返回true，如果想要自行封装基本类型值，可以使用object函数。
拆封
如果想要得到封装对象中的基本类型值，可以使用valueOf函数：
var a = new String("abc"); console.log(a.valueOf());//abc
日期Date
创建日期对象必须使用new Date() Date可以带参数用来指定日期和时间，而不带参数的话，则使用当前的日期和时间。
强制类型装换
强制类型转换分为隐式转换和显示转换，这两种转换的区别是根据你对程序的理解来定义的。例如：
var a = 42; var b = a + "";//隐式转换 var c = String(a);//显示转换
如果你对a+""理解的话，那么这行代码对你来说也是显式转换。
ToString方法
基本类型字符串化规则为：null转换为"null"，undefined转换为"undefined" true转换为"true"，数字的字符串化则最需通用规则。
对普通对象来说，除非自行定义，否则tostring返回内部属性Class的值，如：[object Object]
JSON字符串化
JSON.stringify在对象中遇到undefined、function、和symbol时会自动将其忽略。(连同属性一起忽略，例如：JSON.stringify({'a':1,'b':2,c:undefined}); 结果为："{"a":1,"b":2}")
replacer
我们可以向JSON.stringify方法传递一个可选参数replacer，可以是数组或者函数，用来指定对象序列号过程中那些属性应该被处理或排除，如果replacer是一个数组，那么它必须是一个字符串数组
其中包含序列化要处理的对象的属性名称，除此之外的属性将被忽略。
如果replacer是一个函数，它会对对象本身调用一次，然后对对象的每个属性各调用一次，每次传递两个参数，建和值，如果要忽略某个键就返回undefined，否则返回指定的值。
例如：
console.log(JSON.stringify(a, ["b", "c"])); //{"b":42,"c":"42"} console.log(JSON.stringify(a, function (k, v) { //{"b":42,"d":[1,2,3]} if (k != "c") { return v; } }));
tonumber
tonumber方法，其中true转换为1，false转为0，undefined转换为NaN，null转换为0
在转换时，先检查是否有valueOf方法，如果有并且返回基本类型值，就使用该值进行强制类型转换，如果没有就使用tostring的返回值来进行强制类型转换。如果valueOf和tostring均不返回基本类型值，会产生typeerror错误。（使用object.crete(null)创建的对象属性为null，并且没有这两个方法）
var a = { valueOf: function () { return "43"; } } var b = { toString: function () { return "43"; } } var c = [4, 3]; c.toString = function () { return this.join(""); } console.log(Number(a)); //43 console.log(Number(b)); //43 console.log(Number(c)); //43 console.log(Number("")); //0 console.log(Number([])); //0 console.log(Number(["abc"])); //NaN
ToBoolean
我们常误以为数值1和0分别等同于true和false，在有些语言中可能是这样，但在JavaScript中布尔值和数字是不一样的，虽然我们可以将1强制转换为true，0转换为false，反之亦然，但它们并不是一回事。
下面这些是可以转换为false的值：
undefined
null
false
+0、-0、NaN
""
我们可以理解为除了以上转换为假值外，其他的都是真值
例如：
var a = "false"; var b = "0"; var c = "''" var d = []; var e = {}; var f = function () { }; console.log(Boolean(a)); //true console.log(Boolean(b));//true console.log(Boolean(c));//true console.log(Boolean(d));//true console.log(Boolean(e));//true console.log(Boolean(f));//true
真值可以无限长，所以无法一一列举，这里只能以假值列表作为参考。
显式强制转换
+运算符
var a = "3.14"; console.log(+a);//3.14
直接转换为数值类型而非数字假发运算，也不是字符串拼接。
var a = "3.14"; var d = 5 + +a; console.log(+d);//8.14
这里需要注意两个+号的问题，如果中间不添加空格的话，那么可能会被按照 ++自增来运算。
var d = new Date(); console.log(+d); //1482134335608 var d = +new Date(); console.log(d); //1482134335609
日期直接转为毫秒数。
不过这样的写法可能在可读性上不是太好，并不推荐使用强制转换来得到毫秒数，所以可以有以下这几种写法，得到毫秒数：
var timestamp = new Date().getTime(); console.log(timestamp);//1482134515222 var timestamp = (new Date()).getTime(); console.log(timestamp);//1482134515222 var timestamp = (new Date).getTime(); console.log(timestamp);//1482134515222 var timestamp = Date.now(); console.log(timestamp);//1482134515222 推荐这种写法
~运算符
~表示字位操作 “非”的相关枪支转换。
~x大致等同于-(x+1)。例如：
console.log(~42);//-43
这里需要注意的是，在-(x+1)中，唯一能够得到0的x值是-1，这个-1是一个稍为值，也就是被赋予了特殊含义的值。程序中一般用大于等于0的值来表示成功，-1表示失败。例如indexOf方法。
那么这种>=0或者==-1的写法不是很好，这种代码被称为“抽象渗漏”，意思是在代码中暴露了底层的实现细节。这里是指用-1作为失败时返回的值，这些细节应该被屏蔽掉。
例如：
var a = "hello"; if (~a.indexOf("lo")) { console.log("true"); } if (!~a.indexOf("li")) { console.log("false"); }
使用这种方法会比>=0更简洁。
~~字位截除
console.log(Math.floor(-49.6)); //-50 console.log(~~-49.6); //-49 优先级更高 console.log(-49.6|0); //-49 优先级低
解析数字字符串
Number()和parseInt()方法的区别：
var a = "42"; var b = "42px"; console.log(Number(a)); //42 console.log(parseInt(a));//42 console.log(Number(b)); //NaN console.log(parseInt(b));//42
可以看到parseint方法是执行到非不可转换为数字的字符时，停止转换，然后返回前面的值，而number方法则是要求整体必须都可以进行转换，才返回，否则返回NaN。
parseint方法的执行过程：
var a = { toString: function () { return "48"; } } console.log(parseInt(a));//48
可以看到，parseInt方法先将参数转换为字符串再进行解析。
!!布尔值转换
var a = 0; console.log(!!a);//false
隐式强制转换
+运算符
当有+运算符左右两端存在字符串时，那么会进行字符串连接，否则会进行加法运算。这是一般的情况下，但还有一种情况：
var a = [1, 2]; var b = [3, 4]; console.log(a + b);//1,23,4
a和b都不是字符串，这里为何会进行拼接呢，这是因为在进行转换时，会先调用数组的valueOf方法，然而数组的valueOf操作无法得到简单的基本类型，所以转而调用tostring方法，这样返回两个字符串后，进行拼接。
a+""和String之间有一个席位的差别需要注意，a+""会调用valueof方法，然后通过tostring转为字符串，而String方法，会直接调用tostring方法。
var a = { valueOf: function () { return 42 }, toString: function () { return 4} } console.log(a + "");//42 console.log(String(a));//4
||和&&
在JavaScript中，它们被称为选择器运算符更恰当。因为和其他语言不同，它们返回的并不是布尔值。
它们返回的是两个操作数中的一个（且仅一个），例如：
var a = 42; var b = "abc"; var c = null; console.log(a || b); //42 console.log(a && b); //42 console.log(c || b); //42 console.log(c && b); //null
可以看出，它们返回的是两个操作数中的一个，而非布尔值。
可以换一个角度来理解：
a||b 可以理解为：
a?a:b
a&&b可以理解为：
a?b:a;
下面是一个常见的用法：
a=a||hello;
还有一种方法并不常见，一般在压缩工具中常见,即：
var a=43; a&&foo();
这种被称为短路，也就是只有a在被定义时，才执行foo方法。
当它们在if中使用时，其实是由if对最后的结果进行了强制类型转换。如：
var a = 42; var b = "abc"; if (a && b) { console.log(true); //true }
也相当于：
var a = 42; var b = "abc"; if (!!a && !!b) { console.log(true); //true }
==和===运算符
我们常见的对它们区别的解释为：==是检查值是否相等，而===是检查值和类型是否相等。
这种解释还不够准确和全面，正确的解释为：==允许在相等比较重进行强制类型转换，而===不允许。
根据第一种解释，我们可以列举为===似乎做的事比==更多，因为它还要检查类型，而第二种则正好相反。
==在比较两个不同类的值会发生隐式强制转换，会将其中之一或两者转换为相同的类型，再进行比较。
例如：
var a = 42; var b = "42"; console.log(a == b); //true console.log(a === b);//false
那么到底是将字符串转换为数值，还是将数值转换为字符串呢，具体的转换规则如下：
如果type(x)是数字，type(y)是字符串，则返回x==ToNumber(y)的结果
如果type(x)是字符串，type(y)是数字，那么则返回ToNumber(x)==y的结果
==最容易出错的一个地方是true和false与其他类型直接的比较：
var a = "42"; var b = true; console.log(a == b); //false
我们都知道"42"是一个真值，那么为什么==的结果不是true呢，看一下规范：
如果type(x)是布尔类型，则返回ToNumber(x)==y的结果
如果type(y)是布尔类型，则返回x==ToNumber(y)的结果
所以在这里，根据规范，先将true转换为1进行比较，变成"42"==1，然而类型仍然不同，在进行转换，"42"被转换为42变成42==1,所以为false。
建议无论何时都不要使用 ==true 或者 ==false
在==中 null和undefined是相当的，也就是说只判断 ==null就可以把undefined的情况也判断进去了。
最特殊的情况：
var i = 2; Number.prototype.valueOf = function () { return i++; } var a = new Number(42); if (a == 2 && a == 3) { console.log(true);//true }
可以看到，判断条件为true，所以最好不要修改内置原型。
所以==会在不经意间就进行了隐式转换，特别需要注意的两点：
如果两边的值中有true或者false，千万不要使用==
如果两边的值有[]、""或者0尽量不要使用==
这时应该使用ongoing===来避免这些不经意间的错误。
抽象关系比较
一般来说比较对象时，会将对象转换为字符串，然后对字母进行比较，比较常见的是"123">"13"为false。但是有几种特殊的情况，如：
var a = { b: 42 }; var b = { b: 43 }; console.log(a < b); //false console.log(a == b);//false console.log(a > b);//false console.log(a <= b);//true console.log(a >= b);//true
这里需要注意的是，为什么a<b和a==b都为false，那么a<=b为什么为true？
因为根据规范，a<=b被处理为a>b然后将结果反转。因为a>b 的结果为false，那么反转的结果为true。
实际上JavaScript在处理>=时，是按照不大于的意思进行处理的，即(!(a<b))的结果。
