一、六种数据类型
javascript的数据类型包括：
（1）基本数据类型：number、string、boolean、null、undefined
（2）对象：object
object又包括Function、Array、Date、ExgReg等
总结如下图：
原始类型（基本类型）：按值访问，可以操作保存在变量中实际的值。原始类型汇总中null和undefined比较特殊。
引用类型：引用类型的值是保存在内存中的对象。
* 与其他语言不同的是，JavaScript不允许直接访问内存中的位置，也就是说不能直接操作对象的内存空间。在操作对象时，实际上是在操作对象的引用而不是实际的对象。所以引用类型的值是按引用访问的。
二、隐式转换
1、递增递减操作符
递增“++” 、 递减“--” 运算符不仅适用于整数，还可以用于字符串、布尔值、浮点数值和对象。
转换方式如下：
（1）是包含有效数字字符的字符串时，先将其转换为数字值，再进行运算
（2）是不包含有效数字字符的字符串时，将其值转换为NaN
（3）是布尔值时，false转换为数值0，true转换为数值1
（4）是对象时，先调用对象的valueOf()方法，以取得一个可供操作的值，如果结果是NaN，调用toString() 方法
|
1
2
3
4
5
6
7
8
9
10
11
12
|
var s1="1",
s2="12abc",
b=true,
o={valueOf:function(){
return -1;
}
};
console.log(++s1);//2
console.log(++s2);//NaN
console.log(++b);//2
console.log(++o);//0
|
2、一元加减操作符
一元加号（+）放在数值前面，对数值不会产生任何影响。
|
1
2
|
var num=25;
num=+num;//还是25
|
在对非数值应用一元加操作符时，该操作符会像Number()转型函数一样对这个值执行转换。
Number类型的转换规则如下：
（1）如是布尔值，true转换为1，false转换为0
（2）如是null，返回0
（3）如是undefined，返回NaN
（4）如是字符串，规则
- 如字符串中只包含数字（包括前面带正负号的情况），将其转换为十进制数值
- 如字符串中包含有效的浮点格式，将其转换为对应的浮动数值
- 如字符串中包含有效的十六进制格式，例如“oxf”，将其转换为相同大小的十进制整数值
- 如字符串为空，转换为0
- 如字符中包含除上述格式之外的字符，将其转换为NaN
（5）如果是对象，调用对象的valueOf()方法，再依照前面的规则转换返回的值，如果转换结果为NaN，调用对象的toString()方法，再依照前面的规则转换
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
var s1="1",
s2="12abc",
s3="0xf",
s4="",
b=true,
f="1.1",
f1="1.1.2",
n=null,
u=undefined,
o={valueOf:function(){
return -1;
}
};
console.log(+s1);//1
console.log(+s2);//NaN
console.log(+s3);//15
console.log(+s4);//0
console.log(+b);//1
console.log(+f);//1.1
console.log(+f1);//NaN
console.log(+n);//0
console.log(+u);//NaN
console.log(+o);//-1
|
一元减号（-）放在数值前面，会改变数值的正负号。
在对非数值应用一元减操作符时，该操作符与一元加操作符遵循一样的规则，最后再将得到的数值转换为负数。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
var s1="1",
s2="12abc",
s3="0xf",
s4="",
b=true,
f="1.1",
f1="1.1.2",
n=null,
u=undefined,
o={valueOf:function(){
return -1;
}
};
console.log(-s1);//-1
console.log(-s2);//NaN
console.log(-s3);//-15
console.log(-s4);//-0
console.log(-b);//-1
console.log(-f);//-1.1
console.log(-f1);//NaN
console.log(-n);//-0
console.log(-u);//NaN
console.log(-o);//1
|
3、加法
加法的操作规则如下：
（1）如果两个操作数都是数值，执行常规的加法计算
- 如有一个操作数是NaN，结果是NaN
- Infinity+Infinity=Infinity
- -Infinity + -Infinity = -Infinity
- Infinity+ -Infinity= NaN
- 0+0=0
（2）如果有一个操作数是字符串：
- 如果两个操作数都是字符串，将两个字符串拼接
- 如果只有一个操作数是字符串，将另一个操作数转换为字符串，然后再将两个字符串拼接
（3）如果有一个操作数是对象、数值或布尔值，则调用它们的toString()方法取得相应的字符串值，在应用上述的字符串规则。对于undefined和null，则分别调用String()函数并取得字符串"undefined"和"null"
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
var r1=5+5;
var r3="5"+"5";
var r2="5"+5;
var r4=5+"5";
var r5=1+undefined;
var r6="1"+undefined;
var r7=1+null;
var r8="1"+null;
console.log(r1);//10
console.log(r2);//'55'
console.log(r3);//'55'
console.log(r4);//'55'
console.log(r5);//NaN
console.log(r6);//'1undefined'
console.log(r7);//1
console.log(r8);//'1null'
|
4、减法
减法的操作规则如下：
（1）如果两个操作数都是数值，执行常规的减法计算
- 如有一个操作数是NaN，结果是NaN
- Infinity-Infinity=NaN
- -Infinity - -Infinity = NaN
- Infinity- -Infinity= Infinity
- -Infinity- Infinity=-Infinity
- 0-0=0
（2）如果有一个操作数是字符串、布尔值、null或undefined，先在后台调用Number()函数将其转换为数值，再计算，如果转换结果是NaN，则结果是NaN
（3）如果有一个操作数是对象，则调用对象的valueOf()方法以取得表示该对象的数值，如果得到的值是NaN，则结果就是NaN。如果对象没有valueOf()方法，则调用toString()方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
var r1=5-5;
var r3="5"-"5";
var r2="5"-5;
var r4=5-"5";
var r5=1-undefined;
var r6="1"-undefined;
var r7=1-null;
var r8="1"-null;<br>var r9=2-"";
console.log(r1);//0
console.log(r2);//0
console.log(r3);//0
console.log(r4);//0
console.log(r5);//NaN
console.log(r6);//NaN
console.log(r7);//1
console.log(r8);//1<br>console.log(r9);//2
|
巧用+/-规则转换类型
|
1
2
3
4
|
var r1=1+"";
var r2="1"-0;
console.log(r1);//'1' 转换成了字符串
console.log(r1);//1 转换成了数字
|
5、乘性操作符
3个乘性操作符：乘法、除法、求模
如果参与乘性操作数不是数值，后台会先使用Number()转型函数将其转换为数值。
也就是说空字符串转为0,true转为1，flase转为0
|
1
2
3
4
5
6
7
8
9
|
var r1=2*null;
var r2=2*"";
var r3=2*true;
var r4=2*undefined;
console.log(r1);//0
console.log(r2);//0
console.log(r3);//2
console.log(r4);//NaN
|
6、关系操作符
关系操作符：< > <= >=
当关系操作符的操作数有非数值时，要进行数据转换，规则如下
（1）如两个操作数都是数值，则执行数值比较
（2）如两个操作数都是字符串，则比较两个字符串对应的字符编码值
（3）如一个操作数是数值，将另一个操作数转换为数值，然后执行数值比较
（4）如果一个操作数是对象，则调用对象的valueOf()方法，再按照上面的规则，如没有valueOf()方法，则调用toString()方法
（5）如一个操作数是布尔值，则先转换为数值，再进行比较，true转换为1，flase转换为0
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
var r1="a">"B";
var r2=1>false;
var r3=1>null;
var r4=1>undefined;
var r5=3>"23";
var r6="3">"23";
var r7="a">2;
var r8=3>NaN;
var r9=3<NaN;
console.log(r1);//true B的字符编码是66，a的字符编码是97
console.log(r2);//true false-->0
console.log(r3);//true null-->0
console.log(r4);//false undefined-->NaN
console.log(r5);//false
console.log(r6);//true
console.log(r7);//false a-->NaN
console.log(r8);//false
console.log(r9);//false
|
7、相等操作符
相等== 不相等 !=
这两个操作符都会先转换操作数，然后再比较它们的相等性
遵循的规则：
（1）如果有一个操作数是布尔值，比较前先转换为数值，false转为0，true转为1
（2）如果一个操作数是字符串，另一个操作数是数值，比较前先将字符串转换为数值
（3）如果一个操作数是对象，另一个操作数不是，则调用对象的valueOf()方法，
（4）null==undefined
（5）在比较相等性前，不能将null和undefined转换为其他任何值
（6）如果一个操作数是NaN，相等操作返回false，不相等操作返回true 。 NaN不等于NaN
（7）如果两个操作数是对象，则比较它们是不是同一个对象，如果两个操作数都指向同一个对象，则相等操作返回true
|
1
2
3
4
5
6
7
8
9
10
11
|
console.log(null==undefined);//true
console.log(NaN==NaN);//false
console.log(NaN!=NaN);//true
console.log(false==0);//true
console.log(true==1);//true
console.log(undefined==0);//false<br>console.log(undefined==false);//false
console.log(null==0);//false
console.log(null==false);//false
console.log("5"==5);//true
console.log(new Object() == new Object());//false
console.log([1, 2] == [1, 2]);//false
|
全等=== 不全等!==
操作规则
类型不同，返回false
类型相同
NaN ≠ NaN
new Object ≠ new Object
null === null
undefined === undefined
|
1
2
3
4
5
6
|
console.log("1"===1);//false
console.log("1"+2===1+"2");//true
console.log(1+"2" === "1" + new Number(2));//true 都转成'12'
console.log(1+true===false +2);//true
console.log(1+null==undefined +1);//false 1+null-->1 undefiend+1-->NaN
console.log("a"-"b"=="b"-"a");//false 前后都转成NaN
|
参考：https://www.cnblogs.com/starof/p/6368048.html
https://www.cnblogs.com/aimee2004/p/5149336.html