强制类型转换
将javascript的值从一种类型转换为另一种类型的值——>类型转换
隐式类型转换——>强制类型转换【返回总是基本类型值，string，number，boolean】。Toprimitive是转原始值，是供javascript内部使用的“抽象操作”。
ToString
对于普通对象，除非自定义toString()方法，否则toString方法返回的是内部属性[[Class]]【Object.prototype.toString()】。
数组默认的toString()方法是经过重新定义的
var a = [1,2,3];
a.toString(); //"1,2,3"
JSON.stringify()序列化
所有安全的JSON值都可以使用JSON.stringify进行字符串化。不安全的JSON值有：undefined,function,symbol。
JSON.stringify(undefined) //undefined
JSON.stringify(function(){}) //undefined
JSON.stringify(Symbol()) //undefined
JSON.stringify([1,undefined,function(){},4]) //"[1,null,null,4]"
其实JSON.stringify序列化对象时，调用的是对象toJSON方法返回的对象。toJSON返回的是一个能够被字符串化的安全的JSON值。
JSON.stringify(obj,replacer,space);
replacer是个函数或者和数组，用于指定对象序列化过程中的数据过滤，类似toJSON。space则是缩进。
ToNumber
true->1，false->0，undefined->NaN，null->0
对象（包括数组）转数字，会先转成相应基本类型值，抽象操作ToPrimitive检查该值有没有valueOf()方法，如果没有就用toString()方法进行强制类型转换，两个方法都么有，会抛出错误【这种情况可以参考用Object.create(null)创建一个没有原型集成的对象，是无法进行强制类型转换的】。
JSON.stringify(Object.create(null)) //"{}"
Number(Object.create(null)) //报错：Cannot convert object to primitive value
String(Object.create(null)) //报错：Cannot convert object to primitive value
Boolean(Object.create(null)) //true(因为{}不在假值列表里面)
但是妥妥的打脸了！！！不晓得是不是浏览器做了专门的边界处理？
ToBoolean
Javascript中的假值：undefined,null,false,+0,-0和NaN，还有空字符串""。假值的强制转换类型为false，假值列表意以外的值都是真值(当然也包括假值的封装对象了)：
var a = new Boolean(false);
var b = new Boolean(0);
var c = new Boolean('');
var d = Boolean(a && b && c) ///true
所有的字符串都是真值，除了''空字符串外，因为它是假值列表中唯一的字符串。
var a = [];
var b = {};
var c = function(){}；
var d = Boolean(a && b && c); //d
因为[]，{}，function(){}都不在假值列表中，所以都是真值【真值列表无限长】
ToPrimitive（data,preferedType）【转换为原始值】
1.如果data是原始值，直接返回
2.否则，如果是对象，调用valueOf()返回原始值
3.否则，调用data.toString()返回原始值
4.否则，报错。
String() 和 new String()，Number() 和new Number()
String()转换遵循ToSting的规则，Number遵循ToNumber规则。字符串的转换还可以直接使用toString()方法。number的转换可以使用一元形式：
var c = "3.14";
var d = 5+ +c;
d //8.14
1 + - + + + - + 1; //2(+只是转换为数字类型，-则即转换为数字类型，而且加了符号-)
一元运算符的常见装13用法：
//将Date对象强制转换为时间戳，以毫秒为单位
var d = new Date();
+d; //1552902330544
var timestamp = +new Date()；
//又或者,可以不用带括号（某些特殊没有参数的函数可以酱紫用）
var timestamp = + new Date;
其实获取当前时间还有其他方法：
var timestamp = new Date().getTime()； //最常用的
var timestamp = Date.now(); //ES5加入的
还有另外一个~运算符（按位非），就是二进制的按位非运算：
:返回2的补码。x => -(x+1)，十进制的按位或就是==>加一取反。
var a = 'Hello World';
~a.indexOf('lo'); //-4 ==>真值
~a.indexOf('ol'); //0 ===>假值
以后判断字符串存在否，可以使用~indexOf()来判断了！！！
解析数字字符串
Number()和parseInt()，前者是转换，后者是解析。转换【不允许含有非数字字符串】和解析【允许含有非数字字符串】不是互相替代关系。
var a = "32";
var b = "32px";
Number(a) //32
Number(b) //NaN
parseInt(a) //32
parseInt(b) //32
解析非字符串
parseInt(1/0,19); //18
//类似于
parseInt("Infinity",19); //18
parseInt(new String(42)) //42
显示转换为布尔值Boolean()
一元运算符！显示将值强制转换为布尔值，所以显示转换为布尔值可以用!!。当然也可以使用Boolean()构造函数。
隐式强制类型转换
有人说是JavaScript的设计缺陷，但是它的作用是减少冗余，让代码更简洁。
var a = [1,2];
var b = [3,4]
a + b; //"1,23,4" "1,2"+"3,4" = "1,23,4"
a和b都是先转换为字符串后进行拼接。如果+操作是字符串，则执行字符串拼接，否则执行数字加法
[] + {} //"[object Object]"
'' + {} //"[object Object]"
{} + [] //0
因为String([]) //"";而String({}) //"[object Object]";Number([]) //0
而{} + [] //{}会被看成一个代码块，而不是一个js对象，+[]就是将[]转换为number，得出0的结果。
隐式转换作用
- 将数字转换为字符串
var a = 42;
var b = a + ""; //"42"
- 字符串强制转换为数字类型
var a = "3.14";
var b = a - 0; //3.14
因为-是数字减法运算符。类似还有a*1，a/1等将字符串转换为数字类型。
var a = [3];
var b = [1];
a - b; //2
上面是先对两个数组进行字符串处理a = '3',b = '1',然后字符串用-时，进行数字转换运算。3 - 1 = 2。
b = String(a) //强制显示转换
b = a + "" //隐式类型转换
下面来个判断函数多个参数时，只有一个参数为真的情况返回true。
function onlyOne(){
var sum = 0;
for(var i = 0;i<arguments.length;i++){
sum += Number(!!arguments[i]);
}
return sum === 1;
}
!!arguments[i] //将参数转换为true或者false。
- 隐式转换为布尔值
(1) if (..) 语句中的条件判断表达式。
(2) for ( .. ; .. ; .. ) 语句中的条件判断表达式（第二个）。
(3) while (..) 和do..while(..) 循环中的条件判断表达式。
(4) ? : 中的条件判断表达式。
(5) 逻辑运算符||（逻辑或）和&&（逻辑与）左边的操作数（作为条件判断表达式）。
条件判断中的判断表达式。遵循ToBoolean规则。 - || 和 &&
他们的返回值是两个操作数中的一个（有且仅有一个）。
var a = 32;
var b = 'abc';
var c = null;
a || b; // 32
a && b; // "abc"
c || b //"abc"
c && b //null
可以看出，||和&&操作符都是首先对一个数进行条件判断，对于||来说，第一个数是true就返回第一个数，而&&条件判断，第一个数是false直接返回第一个数，否则返回第二个数。
可以称呼他们为“操作数选择器”。
a || b === a ? a : b
a && b === a ? b : a
&&的妙用
function foo(){
console.log(a)
}
var a = 42;
//短路机制
a && foo()；
//其所用相当于
if(a){
foo()；
}
- 符号的强制类型转换
var s1 = Symbol('cool');
String(s1) //"Symbol(cool)"
var s2 = Symbol("not cool");
s2 + ""; //TypeError
!!s1 //true
符号不能被强制转换为数字，但可以强制转换为布尔值,结果都是true。
宽松相等==和严格相等
解释一：“==检查值是否相等，===检查值和类型是否相等。这样子的描述仍然是不准确的！”
解释二：==允许在相等比较中进行强制类型转换，而===则不允许
解释一中可以看出===干的活似乎更多些，不止要检查类型还要检查值，解释二中==似乎干的活多些，因为如果类型不同，需要进行强制类型转换。
JavaScript引擎针对类型转换时间是微秒级的，可以不用在乎性能。所以：==和===都会检查数据类型，区别在于操作数据类型的处理方式不同，解释二是正确的，而解释一是不准确的。
而在比较对象相等时，==和===是一样的。
var a = 42;
var b = "42";
a === b //false
a == b //true，b会被转换为number类型进行比较
var a = "42";
var b = true;
a == b; //false ===> 42 == 1
遇到有布尔类型的宽松相等，还是都强制转换为数字进行对比。
任何情况下都不要使用==true和==false
而且在==宽松相等中，null和undefined是一回事呢！
null == undefined; //true
对象和非对象之间的==比较
都是将对象ToPromitive化【先调用对象的valueOf()，其默认返回的还是对象本身[捂脸]，如果没有则调用对象的toString()】，然后再进行比较。
var a = 42;
var b = [ 42 ];
a == b; // true
宽松相等==》null和undefined宽松相等，就是一回事，与其他任何值都不宽松相等；布尔值和其他类型比较，布尔先转化为数字后进行比较；字符串和数字比较，统一转化为数字进行比较；对象和非对象之间宽松相等比较，将对象toPrimitive后得到的基本类型，进行比较。
//对象的宽松相等,但是一般定义的对象，其valueOf返回的仍然是对象本身
var a = new String('123');
a == '123'; //true
看个比较奇怪的情况：
if(a == 2 && a == 3){
//...
}
var i = 2;
Number.prototype.valueOf = function(){
i++;
}
var a = new Number(12);
if(a == 2 && a == 3){
console.log("Yep, this happened.")
}
//Yep, this happened.
不常见的假值比较：
"0" == false; // true ---> 0 == 0
false == 0 //true ===> 0 == 0
false == "" //true ===> false == false
//因为Number("") ---> 0，Number(false) ---> 0,Number([])---> 0,所以
"" == 0 //true
"" == [] //true
false == 0 //true
false == "" // true
false == [] //true
0 == [] //true
//更极端的情况
[] == ![] //true 因为![] 是false。[] == false是true
