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得到的不是基本类型，则报错

1. 从左至右进行分割运算
2. 优先级低的向优先级高的类型进行转换
3. 如果转换后两边都不是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 类型不同，先转换

1. null和undefined相等

null == undefined //true

2. 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

3. 其他类型进行转换时都不相等（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不会执行