类型转换

对象在进行类型转换会先valueOf在toString，并且Symbol.primitive 转基本类型时候优先级最高

在加法运算中，如果有一方是字符串，那么另一方也会转成字符串。

其他运算中如果有数字，那么另一方也会变成数字类型

console.log("'1'+1=", '1'+1); //11
console.log("2*'2'=", 2*'2') //4
console.log("1+NaN=", 1+NaN); //NaN
// console.log('null.toString()', null.toString())
console.log("1+null=", 1+null);  //1
console.log("1+'null22'=", 1+'null22');  //1null2
console.log("1*null=", 1*null);  //0
console.log("1+undefined=", 1+undefined); //NaN
var x =5;
console.log("'5'+x -x=", '5'+x -x)  //50
console.log("'5'-x +x=", '5'-x +x)  //5
console.log("123+{}=",123+{}); //123[object Object]
console.log("123+[]=",123+[]); //123

3.parseInt，牵扯的隐式转换

var arr = [1,2,3,2,5];
var arr2 = [1,2,3,4,5,11];
console.log(arr.map(parseInt));  //[1, NaN, NaN, 2, NaN]
console.log(arr2.map(parseInt));  //[1, NaN, NaN, NaN, NaN,6]
console.log(parseInt(1, 0)) // 1
console.log(parseInt(2, 1)) // 1进制，2不在，输出NaN
console.log(parseInt(3, 2)) // 2进制，3不在0-2之间，输出NaN
console.log(parseInt(2, 3)) // 3进制，2在0-3之间，输出2
console.log(parseInt(5, 4)) // 4进制，5不在0-4之间，输出NaN
console.log(parseInt(11, 5)) // 5进制， 1*5^1+1*5^0 = 6

console.log("parseInt(10, 2)=", parseInt(10, 2)) //NaN
console.log("parseInt(20, 2)=", parseInt(20, 2)) //NaN
console.log("parseInt(1, 2)=", parseInt(1, 2)) //1
console.log("parseInt(2, 2)=", parseInt(2, 2)) //
console.log("parseInt(20, 3)=", parseInt(20, 3)) //2*3^1+0*3^0 =6
console.log("parseInt(254, 2)=", parseInt(254, 2)) //NaN

4.NaN 属性表示非数字值（"Not-a-Number"）。此属性指示值不是合法数字。
这个数值用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。
任何与NaN进行运算的结果均会为NaN,NaN与自身不相等（NaN不与任何值相等）。

var a = [2, 1];
var b = [1, 2];
//a.toSting() = 2, 1
//b.toSting() = 1, 2
console.log(a+b);  //输出：2,11,2

5.null 比较特殊，比较运算符 >= <= > < 会对其进行数据类型转换；
相等运算符 == != 不会对其进行数据类型转换

console.log(null <= 0); // true
console.log(null >= 0); // true
console.log(null == 0); // false 
console.log(null - 0); // 0
console.log("2">10);  //false
console.log("2">"10");  //true
console.log("abc">"b"); //false
console.log("abc">"aad"); //true
console.log(NaN>NaN);  //false

//特殊情况
console.log(undefined == null); //true
console.log(undefined == undefined); //true
console.log(undefined === undefined);//true
console.log(null == null);//true
console.log(null === null);//true

1.当运算符旁边有一个是string类型是，会使用Number转成数字类型在进行比较 console.log("2">10); //false

2.如果关系运算符两边都是string的话，同时转成Number类型在进行比较，注意此时并不是按照number转成数字，而是按照字符串对应的unicode编码来转成数字

console.log("2">"10");  为true, 
console.log("abc">"b"); //false 因为默认返回第一个字符的编码，先比较‘a’和‘b’
console.log("abc">"aad"); //true  从左到右的字符比较，因为a相等，比较ba

比较null,undefined相等性之前，不能将这俩转成其他值，规定null,undefined是相等的，他们都代表无效的值。两个相等
undefined派生自null，你可以按原型链来理解吧，object的原型对象是null，然后所有包装对象都是object那出来的，就是root(根)上的root

console.log(null === undefined); // false，类型不同，所以不相等

复杂数据类型在隐式转换时会先转成String，然后再转成Number运算

复杂数据类型转换成number运算，先使用valueOf()方法获取原始值，如果原始值不是number类型，则使用toString()方法转成string，再转成Number类型运算

console.log([1,2] == "1,2");// true
var a ={};
console.log( a == "[object Object]");// true
console.log( a.valueOf().toString()); //[object Object]

说起number转换

console.log(Number(undefined));  //NaN
console.log(Number(function(){})); //NaN
console.log(Number({})); // NaN
console.log(Number("asds")); // NaN
console.log(Number(['1','2']));  //NaN

console.log(Number('123')); //123
console.log(Number('')); //0
console.log(Number(true)); //1
console.log(Number(null)); //0
console.log(Number([]));  //0
console.log(Number(['2']));  //2
只有数字内容字符串（“123”）、空字符串（“”）、Boolean类型、null、空数组（[ ]）、单数字数组（[1]）可以转换为数字类型

逻辑非隐式转换与关系运算符隐式转换搞混淆

空数组的toString()方法会得到空字符串，而空对象的toString()方法会得到字符串[object Object] （注意第一个小写o，第二个大写O哟）

console.log([] == 0);  //true
console.log(![] == 0); //true
console.log([].valueOf());  //[]
console.log([].valueOf().toString()); ""
console.log(Number([].valueOf().toString()));  //0

console.log([] == 0); 空数组转原始值转字符串转数字类型为0

console.log(![] == 0); 这里注意，逻辑非运算符优先级大于关系运算符，![] 先转成布尔类型，[]为true，![] = false, false =0

console.log([] == []); //false
console.log([] == ![]); // true
console.log({} == !{}); // false
console.log({}.valueOf().toString());  //[object Object]
console.log(Number({}.valueOf().toString()));  //NaN
console.log(!{});  //false
console.log({} == {}); // false
console.log([] == []); //false
console.log({} == {}); // false 引用类型数据存储在堆中，栈中存的是地址。所以结果是false
console.log({} == !{});  {}转换之后为NaN，!{}转为false  ，
console.log({} == !{}); // false

说一个特殊的例子

 [] == ![] // -> true
console.log("[] == ![] ",[] == ![]);
[] == true ,取反！ == false
所以[] == false;
然后[] == toNumber(false)
 [] == 0
toNumber([]) == 0
 [].toString() ->''
 ''=>0
 0 == 0