JS中的运算符

---

前言

在编程语言中，运算符的分类：

1. 数学运算符。
2. 赋值运算符。
3. 关系运算符。
4. 逻辑运算符。
5. 位运算符。
6. 自增自减运算符。
7. 其它运算符 typeof
   

---

一、数学运算符

数学运算符:
作用：进行数学运算
+ - * / % **
+ a**b 表示a的b次方 …

    <script>
        console.log(10 * 10);
        console.log(10 % 3);
        console.log(3 % 10);
        console.log(2 ** 3);
    </script>

二、赋值运算符

1. =
2. +=
3. -=
4. *=
5. /=
6. %=

这些都叫赋值运算符。

    <script>
        // a是变量名  变量名是内存空间的别名
        var a = 110; // 把110赋值给a所对应的内存空间
        console.log(a); // 对a的操作就是对a所对应的内存空间操作

        // 把666赋值给c  c的值是666
        //    c = 666 这是一个整体 =叫赋值运算符  赋值运算符有副作用
        //    副作用：整体也有一个值，这个值是左值  整体的值和c的值一样的
        //   b = 666  666是 c=666整体的值
        var a = b = c = 666;
        console.log(a,b,c);
    </script>

    <script>
        var a = 110;
        a = a+666;// a+666 是776  把776赋值给a  把776重新放到a所对应的内存空间中
        console.log(a);

        // a = a+666  ==>  a += 666;
    
        var b = 222;
        b -= 234;  // b -= 234 => b = b - 234;
        console.log(b);

        var c = 124;
        c /= 2; // c = c/2;
        console.log(c);
    </script>

三、关系运算符

关系运算符（比较运算符）：最终得到的结果是boolean类型。

1. “>” ，左边大于右边 结果true，否则为false。
2. “<” ，左边小于右边 结果true，否则为false。
3. " >=" ，左边大于等于右边 结果true，否则为false。
4. “”<= ，左边小于或等于右边 结果true，否则为false
5. " == "， 等号 运算符两侧的数据类型不一致，会发生数据类型的隐式转化,比较两边的操作数的是否相等，不管数据类型 100 == “100”.
6. " === " ，绝对等于
   比较两边的操作数的是否相等，数据类型也需要比较 100 === “100”
   != 是 == 的取反操作
   比较两边的操作数的是否不等，不管数据类型 100 != “110”
   !== 是===取反操作
   比较两边的操作数的是否不等，数据类型也需要比较

<script>
        console.log(10>20);
        console.log(20>20);
        console.log(30>20);

        console.log("-----------");

        console.log(10<20);
        console.log(10<10);
        console.log(10<5);

        console.log("-----------");

        console.log( 1 == 1 );
        // == 不比较数据类型  会发生数据类型的隐式转化
        console.log( 1 == "1" );
        // true会隐式类型转化成1
        console.log( 1 == true );
        console.log( 1 == 2 );
        // undefined 和 null 都会隐式类型转化成false
        console.log(undefined == null);
        // NaN和任何值比较都是false
        console.log(NaN == NaN);
        console.log(NaN == 123);
    </script>

    <script>
        console.log( 1 === "1" );
        console.log( 1 === 1 );
        console.log( 1 != 2);
        // !=不比较类型
        console.log( 1 != "1");  // false
        console.log( 1 != "1abc"); // true
        console.log("---------");
        console.log(1 !== "2"); // === 
        console.log(10 !== 20);  // === 
    </script>

四、逻辑运算符

逻辑运算符：

1. && 逻辑与 且。两边的操作数都为true，整体的结果才为ture。只要一边的为false，整体的结果就为false。
2. || 逻辑或。只要一边的为true，整体的结果就为true当两边的都为false，整体的结果就为false。
3. ！ 逻辑非。 如果本身为true，结果就是false。如果本身为false，结果就是true。双取反可以转布尔。

    <script>
        console.log(true && true);
        console.log(true && false);
        console.log(false && true);
        console.log(false && false);

        console.log("--------");

        console.log(true || true);  // true
        console.log(true || false);  // true
        console.log(false || true);  // true
        console.log(false || false);  // false

        console.log("--------");

        console.log(!true);
        console.log(!false);
        // 双取反可以转布尔
        console.log(!!110);
        console.log(!!0);
        console.log(!!"");
        console.log(!!undefined);
    </script>

五、位运算符

后面说。

六、自增自减运算符

++ – ： ++就表示+1 --就表示-1 在开发项目时，+1和-1用的非常多，基本上所有的编程语言都封装了+1和-1运算符

---

++ 分两类： i++ ++在前，或++在后，i的值都要加1 前置++ 可以让i加1 整体的值是一个新值 后置++ 也可以让i加1 整体的值是一个旧值 -- 分两类： 前置-- 后置-- ```html

```html
<script>
       /*  var k = 1;
        // k++整体也有一个值 如果++在后，整体的值是旧值
        // 所谓的旧值就是指没有加1的值
        var r = k++;  // k的值肯定要加1
        console.log(k); // k是2
        console.log(r); */

       /*  var j = 100;
        var k = ++j;
        console.log(j); // 101
        console.log(k);  // 101 */

       /*  var n = 5;
        n++;
        ++n;
        console.log(n); */

        var n = 100;
        // + 加号   ++自增运算符
        // 要考虑运算符的优先级
        // 参考：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
        // +的优先级是：14  自增运算符的优先级是：17
        // 自增运算符的优先级 > +的优先级是
        // 先算++
        // 10后面加的是++n整体  整体是新值
        var res = 10 + ++n;  // ++n n的值是101  ++n整体的值是101
        console.log(res);
    </script>

<script>
       /*  let i = 1;
        // i++ 整体是旧值  ++在后，整体是旧值
        let k = i++ + 666;
        console.log(k); // 667 */

        let n = 1;
        // n = 1  
        // n++ n的值是2  整体的值是1
        // ++n n的值是3  整体的值是3
        // ++n n的值是4  整体的值是4  
        // n++ n的值是5  整体的值是4
        // 还要考虑运算符的优先级
        // 如果运算符的优先级一样，从左向右进行运算
        var res = n++ + ++n + ++n + n++
        //         1     3     4     4
        console.log(res); // 9  12  11  7 
    </script>