JS 运算符运算规则

1. 类型转换规则

JavaScript的数据类型：

① 基本数据类型：Number、String、Boolean、Null、Undefined、BigInt、Symbol

② 复杂数据类型：Object、Array、Function、RegExp、Date、Error

③ 全局数据类型：Math

对象转数字：分两步，对象 → 基本 → 数字

对象转字符串：分两步，对象 → 基本 → 字符串

1.1 基本 → 数字

string: 空字符串（含空白字符）: 0
去掉引号，不是数字就是 NaN

        true:   1
        false: 0
        null: 0
        undefined: NaN

Number('')              // 0
Number('   ')           // 0
Number(' \n\r\t ')      // 0
Number('123')           // 123
Number('  123  ')       // 123
Number('123a')          // NaN
Number('  12  3  ')     // NaN
Number(true)            // 1
Number(false)           // 0
Number(null)            // 0
Number(undefined)       // NaN

1.2 所有 → 布尔

只需要记住哪些情况是 false，其余情况都是 true

flase：0、NaN、空字符串、null、undefined

Boolean(0)          // false
Boolean(NaN)        // false
Boolean('')         // false
Boolean(null)       // false
Boolean(undefined)  // false
Boolean({})         // true
Boolean([])         // true

1.3 基本 → 字符串

number: '数字'

扫描二维码关注公众号，回复： 16499103 查看本文章

boolean： true: 'true'

false: 'false'

null: 'null'

undefined: 'undefined'

1.4 对象 → 基本

对象转基本类型：先调用 valueOf → 得到的是对象? 重新调用 toString → 得到的还是对象? 报错

var obj = {};
// console.log(+obj);   加号放前面表示正数，期望把对象转成数字
console.log(obj.valueOf());    // {}
console.log(obj.toString());   // '[object Object]'
console.log(Number('[object object]');    // NaN
console.log(+obj);             // 最终结果为：NaN

// 如果修改 obj 的 valueOf
var obj = {
    valueOf() {
        return 1;
    }
};
console.log(+obj);    // 最终结果为：1

// 如果调用 toString 方法得到的还是对象，则程序报错
var obj = {
    valueOf() {
        return {};
    },
    toString() {
        return {};
    }
};
console.log(+obj);    // 最终结果为：TypeError: Cannot convert object to primitive value at Object.<anonymous>

2. 运算规则

2.1 算术运算

1. 先转换成基本类型

2. 转换成数字，然后运算

特殊情况：

① x + y，x 和 y 有一个是字符串：转换成字符串，然后拼接

② NaN 和任何类型算术运算得到的还是 NaN

// console.log(null + undefined);
// 1. 先看两边是不是基本类型：是
// 2. 再看两边是不是特殊情况：不是特殊情况
// 3. 转成数字：null 转换成数字 0，undefined 转换成数字 NaN
// 相当于 console.log(0 + NaN);
console.log(null + undefined);    // 最终结果为：NaN

// 经典面试题 console.log({} + []);
// 1. 先看两边是不是基本类型：不是
// 2. 转成原始类型
//  {} 转成基本类型：
console.log({}.valueOf());    // {}
console.log({}.toString());   // '[object Object]'
//  [] 转成基本类型：
console.log([].valueOf());    // []
console.log([].toString());   // ''
//  相当于 console.log('[object Object]' + '');
// 3. 看两边是不是特殊情况：是
//  特殊情况中的左右含有字符串，因此拼接
console.log({} + []);         // 最终结果为：'[object Object]'

2.2 比较运算

< > <= >= ：转换成基本类型

== ： ① 两端类型相同，比较值

② 两端都是基本类型，转换成数字比较

③ 一端是基本类型，一端是对象类型，把对象转成基本类型后比较

④ 特殊情况：undefined 和 null 只有与自身比较，或者互相比较时，才会返回 true

⑤ 特殊情况：两端存在 NaN，一定为 false

=== ：类型和值必须都相同

!= !==：对相等的结果取反

null > 0            // false
null >= 0           // true
undefined >= 0      // false
null >= undefined   // false

null == 0           // false
null == undefined   // true

NaN > 0             // false

2.3 逻辑运算

转换成 Boolean

x && y：都为 true 时，返回 true

x || y：有一个为 true 时，返回 true

3. 表达式

数据：字面量、变量、表达式