运算符的分类

运算符的分类

JS 中的运算符，分类如下：

• 算数运算符

• 自增/自减运算符

• 一元运算符

• 三元运算符（条件运算符）

• 逻辑运算符

• 赋值运算符

• 比较运算符

下面来逐一讲解。

算术运算符

用于执行两个变量或值的算术运算。

此外，算数运算符存在隐式类型转换的情况，前文“数据类型转换”一节中已讲过，本文不再赘述。

常见的算数运算符有以下几种：

// base data
 var n = 345;
 while (n!=0) {
    var mod = n % 10;
    n = parseInt(n  / 10);
    console.log(mod) // 5   4   3
    
 }

算术运算符的运算规则

（1）* / % 的优先级高于 + -

（2）无论是+ - * / %都是左结合性（从左至右计算）

（3）小括号( )：能够影响计算顺序，且可以嵌套。没有中括号、没有大括号，只有小括号。

（4）特别需要注意的是取余运算如下

余数 = m % n;
console.log(5 % 3)  //2
console.log(5 % -3) //2
console.log(-5 % 3) // -2 
console.log(-5 % -3) // -2 
console.log(-3 % -5) // -3

• 取余运算结果的正负性，取决于 m，而不是 n。比如：10 % -3的运算结果是 1。-10 % 3的运算结果是-1。

• 如果 n < 0，那就先把 n 取绝对值后，再计算。等价于 m % (-n)。

• 如果 n 是 0，那么结果是 NaN。

• 在 n > 0 的情况下：

  • 如果 m>=n，那就正常取余。

  • 如果 m<n，那结果就是 m。

自增运算符

自++

作用：可以快速对一个变量进行加1操作。只能操作变量，不能操作常量或者表达式。

var a = 1;
var b = 1;
a++
b++
console.log(a)  // 2
console.log(b)  //2 
var res1 = (a++) +  b;
console.log(res1) // 4
console.log(a)  // 3
console.log(b) // 2
var res2 = (++a) +  b;
console.log(res2) // 6
console.log(a)   //4 
console.log(b)   //2 

自增分成两种：a++和++a。共同点：

（1）无论是 a++ 还是++a，自增都会使原变量的值加 1。

（2）我们要注意的是：a是变量，而a++和++a是表达式。

那这两种自增，有啥区别呢？区别是：a++ 和 ++a的值不同：（也就是说，表达式的值不同）

• a++这个表达式的值等于原变量的值（a 自增前的值）。可以这样理解：先把 a 的值赋值给表达式，然后 a 再自增。

• ++a这个表达式的值等于新值 （a 自增后的值）。 可以这样理解：a 先自增，然后把自增后的值赋值给表达式。

自--

作用：可以快速对一个变量进行减1操作。原理同自增运算符。

开发时，大多使用后置的自增/自减，并且代码独占一行，例如：num++，或者 num--。

隐式类型转换

自增和自减时，a的执行过程：

（1）先调用Number(a)函数；

（2）然后将Number(a)的返回结果进行 加 1 操作，得到的结果赋值给 a。

举例 1：

let a = '666'; // 这里不能用 const 定义，否则报错。
a++;
​
console.log(a); // 打印结果：667
console.log(typeof a); // 打印结果： number

举例2：

let a = 'abc';
a++;
​
console.log(a); // 打印结果：NaN。因为 Number('abc')的结果为 NaN，再自增后，结果依然是 NaN
console.log(typeof a); // 打印结果：number

一元运算符

一元运算符，只需要一个操作数。常见的一元运算符如下。

typeof

typeof 是典型的一元运算符，因为后面只跟一个操作数。

因为 JS是弱类型语言，是松散型语言，所以我们不需要显式指定数据的具体类型。但是很多时候，我们仍需要通过一种手段知道某个变量到底是哪一种数据类型，typeof 运算符应运而生。

typeof()表示“获取变量的数据类型”，它是 JS 提供的一个操作符。返回的是小写，语法为：（两种写法都可以）

// 写法1
typeof 变量;
// 写法2
typeof(变量);

typeof 这个运算符的返回结果就是变量的数据类型。那返回结果的类型是什么呢？是字符串。

typeof 是一个运算符，或者说是一个操作符，所以说，typeof() 并不是一个函数，()只是将括起来的内容当做一个整体而已。

延伸一下，() 这个符号至少有两个作用：

• 作用1：调用函数

• 作用2：表示括起来的内容/表达式是一个整体。比如 1+2*3 与 (1+2)*3的写法是有区别的。

typeof() 的返回结果：

备注：

• 为啥 typeof null的返回值也是 object 呢？因为 null 代表的是空对象。

• typeof NaN的返回值是 number，之前的内容中讲过，NaN 是一个特殊的数字。

返回结果举例：

var a = '123';
console.log(typeof a); // 打印结果：string
​
console.log(typeof []); // 空数组的打印结果：object
​
console.log(typeof {}); // 空对象的打印结果：object

代码解释：这里的空数组[]、空对象{} ，为啥他们在使用 typeof 时，返回值也是 object呢？因为空数组、空对象都是引用数据类型 Object。

typeof 无法区分数组，但 instanceof 可以。比如：

console.log([] instanceof Array); // 打印结果：true
​
console.log({} instanceof Array); // 打印结果：false

关于 instanceof 的详细内容，以后讲对象的时候，会详细介绍。

正号/负号：+a、-a

注意，这里说的是正号/负号，不是加号/减号。

（1）不会改变原数值。

（1）正号不会对数字产生任何影响。比如说，2和+2是一样的。

（2）我们可以对其他的数据类型使用+，来将其转换为 number【重要的小技巧】。比如：

var a = true;
a = +a; // 注意这行代码的一元运算符操作
console.log('a：' + a);  //  a：1
console.log(typeof a);  // number
​
console.log('-----------------');
​
var b = '18';
b = +b; // 注意这行代码的一元运算符操作
console.log('b：' + b); //  b：18
console.log(typeof b);  //  number

（3）负号可以对数字进行取反。

隐式类型转换——正号/负号

任何值做+a、-a运算时， 内部调用的是 Number() 函数。

举例：

const a = '666';
const b = +a; // 对 a 进行一元运算，b是运算结果
​
console.log(typeof a); // 打印结果：string。说明 a 的数据类型保持不变。
console.log(a); // 打印结果："666"。不会改变原数值。
​
console.log(typeof b); // 打印结果：number。说明 b 的数据类型发生了变化。
console.log(b); // 打印结果：666

三目运算符

三目运算符也叫三元运算符、条件运算符。

语法：

条件表达式 ? 语句1 : 语句2;

执行流程——条件运算符在执行时，首先对条件表达式进行求值：

• 如果该值为 true，则执行语句 1，并返回执行结果

• 如果该值为 false，则执行语句 2，并返回执行结果

如果条件表达式的求值结果是一个非布尔值，会将其转换为布尔值然后再运算。

逻辑运算符

逻辑运算符有三个：

• &&： 与（且）。两个都为真，结果才为真。特点：一假则假。

• || ：或。只要有一个是真，结果就是真。特点：特点: 一真则真。

• ! ：非。对一个布尔值进行取反。特点: 真变假, 假变真。

1、两个非布尔值，做逻辑运算：

与运算的返回结果：

• 如果第一个值为 false，则只执行第一条语句，并直接返回第一个值；不会再往后执行。

• 如果第一个值为 true，则继续执行第二条语句，并返回第二个值（无论第二个值的结果如何）。

或运算的返回结果：

• 如果第一个值为 true，则只执行第一条语句，并直接返回第一个值；不会再往后执行。

• 如果第一个值为 false，则继续执行第二条语句，并返回第二个值（无论第二个值的结果如何）。

2、三个及以上的非布尔值，做逻辑运算：

与运算的返回结果：（value1 && value2 && value3）

• 从左到右依次计算操作数，找到第一个为 false 的值为止。

• 如果所有的值都为 true，则返回最后一个值。

或运算的返回结果：（value1 || value2 || value3）

• 从左到右依次计算操作数，找到第一个为 true 的值为止。

• 如果所有的值都为 false，则返回最后一个值。

赋值运算符

• = 直接赋值。比如 var a = 5。意思是，把 5 这个值，往 a 里面存一份。简称：把 5 赋值给 a。

• +=：比如 a += 5 等价于 a = a + 5。

• -=：比如 a -= 5 等价于 a = a - 5。

• *=：比如 a _ = 5 等价于 a = a -5。

• /=：比如 a /= 5 等价于 a = a / 5。

• %=：比如 a %= 5 等价于 a = a % 5。

注意：

1. 算数运算符的优先级高于赋值运算符。

2. 赋值运算符的结合性是右结合性（从右至左的顺序计算）

比较运算符

较运算符可以比较两个值之间的大小关系，如果关系成立它会返回 true，如果关系不成立则返回 false。

比较运算符有很多种，比如：

>   大于号
<   小于号
>=  大于或等于
<=  小于或等于
==  等于
=== 全等于
!=  不等于
!== 不全等于

比较运算符，得到的结果都是布尔值：要么是 true，要么是 false。如果关系成立，就返回true；如果关系不成立，就返回false。

举例如下：

const result = 5 > 10; // false

非数值的比较

（1）对于非数值进行比较时，会将其转换为数值类型（内部是调用Number()方法），再进行比较。

举例如下：

console.log(1 > true); //false
console.log(1 >= true); //true
console.log(1 > '0'); //true
​
//console.log(10 > null); //true
​
//任何值和NaN做任何比较都是false
​
console.log(10 <= 'hello'); //false
console.log(true > false); //true

（2）特殊情况：如果参与比较的都是字符串，则不会将其转换为数字进行比较，比较的是字符串的Unicode 编码。【非常重要，这里是个大坑，很容易踩到】

比较字符编码时，是一位一位进行比较，顺序从左到右。如果大一样，则继续比较下一位。

比如说，当你尝试去比较"123"和"56"这两个字符串时，你会发现，字符串"56"竟然比字符串"123"要大（因为 5 比 1 大）。也就是说，下面这样代码的打印结果，其实是 true:（这个我们一定要注意，在日常开发中，很容易忽视）

// 比较两个字符串时，比较的是字符串的字符编码，所以可能会得到不可预期的结果
console.log('56' > '123'); // true

因此：当我们想比较两个字符串型的数字时，一定一定要先转型再比较大小，比如 parseInt()。

（3）任何值和 NaN 做任何比较都是 false。

==符号的强调

==这个符号，它是判断是否等于，而不是赋值。注意事项如下：

（1）==这个符号，还可以验证字符串是否相同。例如：

console.log('我爱你中国' == '我爱你中国'); // 输出结果为true

2）==这个符号并不严谨，会做隐式转换，将不同的数据类型，转为相同类型进行比较。例如：

console.log('6' == 6); // 打印结果：true。这里的字符串"6"会先转换为数字6，然后再进行比较
console.log(true == '1'); // 打印结果：true
console.log(0 == -0); // 打印结果：true
​
console.log(null == 0); // 打印结果：false

（3）undefined 衍生自 null，所以这两个值做相等判断时，会返回 true。

console.log(undefined == null); //打印结果：true。

（4）NaN 不和任何值相等，包括它本身。

console.log(NaN == NaN); //false
console.log(NaN === NaN); //false

问题：那如果我想判断 b 的值是否为 NaN，该怎么办呢？

答案：可以通过 isNaN()函数来判断一个值是否是 NaN。举例：

console.log(isNaN(b));

如上方代码所示，如果 b 为 NaN，则返回 true；否则返回 false。

===全等符号的强调

全等在比较时，不会做类型转换。如果要保证完全等于（即：不仅要判断取值相等，还要判断数据类型相同），我们就要用三个等号===。例如：

console.log('6' === 6); //false
console.log(6 === 6); //true

上述内容分析出：

• ==两个等号，不严谨，"6"和 6 是 true。

• ===三个等号，严谨，"6"和 6 是 false。

另外还有：==的反面是!=，===的反面是!==。例如：

console.log(3 != 8); // true
console.log(3 != '3'); // false，因为3=="3"是true，所以反过来就是false。
console.log(3 !== '3'); // true，应为3==="3"是false，所以反过来是true。