1. 前置知识
2. - * / %运算符
Number类型直接进行数学运算，非Number类型，转换成Number类型后，进行数学运算
3. + 运算符
3.1 作为一元运算符
表示对对象进行Number()转换
console.log(+{});//NaN
console.log(+["Lawson", "Nion"]);//NaN
console.log(+[]);//0
console.log(+false);//0
console.log(+"123");//123
console.log(+null);//0
console.log(+undefined);//NaN
3.2 作为二目运算符
+号左右两边有一个有优先级高的，就往这个类型转
- 优先级顺序：
String>Number>Boolean==null==undefined -
Object特殊处理，得到基本类型后再进行优先级判定- 若有
valueOf()方法，则先调用，若得到基本类型，则使用 - 若没有
valueOf()方法或者valueOf()方法返回不是基本类型，则尝试调用toString()方法 - 若有
toString()方法，则调用，若得到基本类型，则使用 - 若没有
toString方法，或者toString得到的不是基本类型，则报错
- 若有
- 从左至右进行分割运算
- 优先级低的向优先级高的类型进行转换
- 如果转换后两边都不是String或者Number，则往Number转
let obj = {
name: "Lawson",
toString() {
console.log("called toString");
return false;
},
valueOf() {
console.log("called valueOf");
return [];
},
};
console.log(1 === 1 + obj);
//called valueOf
//called toString
//true
//先得到了false，Boolean和Number，Number优先级高，往Number转换
//1 + false => 1 + 0 => 1
let obj = {
name: "Lawson",
toString() {
console.log("called toString");
return 1;
},
valueOf() {
console.log("called valueOf");
return [];
},
};
console.log(true + obj);
//called valueOf
//called toString
//2
//先得到了1，Boolean和Number，Number优先级高，往Number转换
//true + 1 => 1 + 1 => 2
console.log(true + false);//1
console.log(true + null);//1
console.log(null + undefined);//NaN
console.log(true + undefined);//NaN
//[]调用valuteOf会得到""，是String，所以都往String转
console.log(null + []);//'null'
//{}被识别为对象，并通过toString()转换成'[object Object]'
console.log(1 + {});//"1[object Object]"
//{}会被识别为代码块
console.log({} + 1);//1
//1 + false => 1 + 0 => 1
//1 + '2' => '1' + '2' => '12'
//'12' + null => '12' + 'null' => '12null'
console.log(1 + false + '2' + null);//'12null'
//1 + false => 1 + 0 => 1
//1+ null => 1 + 0 => 1
//1 + '2' => '1' + '2' => '12'
console.log(1 + false + null + '2');//'12'
//false + null => 0 + 0 => 0
//0 + 1 => 1
//1 + '2' => '1' + '2' => '12'
console.log(false + null + 1 + '2');//'12'
//false + null => 0 + 0 => 0
//0 + '2' => '0' + '2' => '02'
//'02' + 1 => '02' + '1' => '021'
console.log(false + null + '2' + 1);//'021'
4. > >= < <=逻辑运算
Number类型直接进行逻辑运算，非Number类型，转换成Number类型后，进行逻辑运算
5. ==逻辑运算
5.1 类型相同，直接比较
-
NaN和NaN不等
NaN == NaN //false
-
Object类型比较堆地址
{} == {} //false
[] == [] //false
[] == {} //false 不进行类型转换
//!Boolean([]) == !Boolean({}) => !true == !true => false == false
![] == !{} //true
//[] == !Boolean([]) => [] == !true => Number([]) == Number(false) => 0 == 0
[] == ![] //true
var a = b = {};
a == b //true
-
+0、-0、0相等 - 其他都相等
5.2 类型不同，先转换
-
null和undefined相等
null == undefined //true
-
Object（Date类型转为String类型）、Number、String、Boolean之间的比较都是返回转换为Number类型进行比较
//Number(123) == Number('123')
123 == '123' //true
//Number(0) == Number(false)
0 == false //true
//Number(0) == Number([]) => 0 == Number('') => 0 == 0
0 == [] //true
//Number(0) == Number({}) => 0 == Number('[object Object]') => 0 == NaN
0 == {} //false
//Number([]) == Number({}) => Number('') == Number('[object Object]') => 0 == NaN
new Date('2020/11/28').valueOf() //1606492800000
new Date('2020/11/28').toString() //"Sat Nov 28 2020 00:00:00 GMT+0800 (中国标准时间)"
new Date('2020/11/28') == "Sat Nov 28 2020 00:00:00 GMT+0800 (中国标准时间)" //true
new Date('2020/11/28') == 1606492800000 //false
- 其他类型进行转换时都不相等（null和undefined与其他类型都不相等）
null == 0 //false
undefined == {} //false
6. && || 逻辑运算
6.1 &&
- 从左往右执行代码块
- 执行代码块A，得出结果resA
- 若
Boolean(resA)为false，则返回resA，不执行代码块B - 若
Boolean(resA)为true，则继续执行代码块B，得出结果resB - 若
Boolean(resB)为false，则返回resB，不执行代码块C - 若
Boolean(resB)为true，则继续执行代码块C，得出结果resC - 依次递进，直到
Boolean(resN)为false，或者执行完所有
function A(){
console.log('called A.');
return [] == ![];
}
function B(){
console.log('called B.');
return undefined + 0;
}
function C(){
console.log('called C.');
return true;
}
console.log(A() && B() && C());//NaN
//called A.
//called B.
//NaN
//A执行，结果为[] == ![]，通过Boolean([] == ![]) => true，会执行一个表达式
//B执行，结果为undefined + 0，通过Boolean(undefined + 0) => false，会停止向下执行，返回undefined + 0的表达式结果undefined + 0 => Number(undefined) + 0 => NaN + 0 => NaN
//C不会执行
6.2 ||
- 每一步的返回值进行Boolean操作
- 返回第一个可转换为true的表达式
- 可转换为true的表达式后面的表达式会被【短路】（不会执行）
function A() {
console.log("called A.");
return [] == [];
}
function B() {
console.log("called B.");
return null + 1;
}
function C() {
console.log("called C.");
return true;
}
console.log(A() || B() || C());
//called A.
//called B.
//1
//A执行，return结果为[] == []，类型相同，直接比较堆地址，不等，计算结果为false，继续向右执行
//B执行，结果为null + 1，通过Boolean(null + 1) => true，会停止向下执行，返回null + 1的表达式结果null + 1 => Number(null) + 1 => 0 + 1 => 1
//C不会执行
