Javascript运算符： 算术运算符 递增/递减运算符 比较运算符（等号区别） 逻辑运算符 赋值运算符 （运算符优先级）

运算符也称 操作符
用于实现赋值、比较和执行算数运算等功能的符号

1.算术运算符

运算符	描述	实例
+	加	10+20=30
-	减	10-20=-10
*	乘	10*20=200
/	除	10/20=0.5
%（取余运算符）	取余数	返回除法的余数9%2=1

        console.log(1 + 1); // 输出结果：2
        console.log(1 - 1); // 输出结果：0
        console.log(1 * 1); // 输出结果：1
        console.log(1 / 1); // 输出结果：1
        //取余运算符作用：判断一个数是否能被整除
        console.log(4 % 2); // 输出结果：0
        console.log(5 % 3); // 输出结果：2
        console.log(3 % 5); // 输出结果：3

浮点数的精度问题

浮点数值的 最高精度是 17 位小数，但在进行算术计算时其精确度远远不如整数。

1.算数运算里面会有问题

2.不能直接拿着浮点数来进行相比较 是否相等(不能直接拿两个浮点数进行比较)

       // 1.
        console.log(0.1 + 0.2); // 输出结果：0.30000000000000004
        console.log(0.07 * 100); // 输出结果：7.000000000000001

        //2.
        var num = 0.1 + 0.2;
        console.log(num == 0.3); //输出结果： false（不相等）

表达式和返回值

表达式：是由数字、运算符、变量等以 能求得数值的有意义排列方法所得的组合（简单理解：是由数字、运算符、变量等组成的式子）

返回值: 返回表达式最终的结果(值)给开发者

        console.log(1 + 1); // 输出结果：2 （输出结果2就是返回值）
        // 1 + 1 = 2
        //程序中 右边 表达式计算完毕把返回值给 左边
        var num = 1 + 1;   

2.递增/递减运算符

• 反复给数字变量添加或减去1，用递增（++）和 递减（ – ）运算符
• 放在变量前面称为前置递增（递减）运算符
• 放在变量后面称为后置递增（递减）运算符。
  注意：
  1.递增和递减运算符必须和变量配合使用。
  2.前置自增和后置自增如果单独使用 效果是一样的

1. 前置递增运算符
   ++num 前置递增，就是自加1，相当于 num = num + 1
   使用口诀：先自加，后返回值

 var num = 1;
        num = num + 1; //相当于 ++num
        num = num + 1;
        console.log(num); // 输出结果：3
        
        var age = 10;
        ++age; // 相当于age = age + 1
        console.log(age);//输出结果：11
        
        // 先加1  后返回值
        var p = 10;
        console.log(++p + 10);//输出结果：21

2. 后置递增运算符
   num++ 后置递增，就是自加1，相当于 num = num + 1
   使用口诀：先返回原值，后自加

       var num = 10;
       num++; 
       console.log(num);
       
        var p = 10;
       console.log(p++ + 10);//输出结果：20(先输出原值再加一)
       console.log(p);//输出结果：11

3.比较运算符（关系运算符）

两个数据进行比较后，返回一个布尔值（true / false）为比较运算的结果。

        console.log(3 >= 5); // 输出结果：false错误
        console.log(2 <= 4); // 输出结果：true正确
        
        //1. 等于符号是 ==  默认转换数据类型 会把字符串型的数据转换为数字型 只要求值相等就可以
        console.log(3 == 5); // 输出结果：false
        console.log('13232' == '45654'); // 输出结果：flase
        console.log(18 == 18); //输出结果： true
        console.log(18 == '18'); // 输出结果：true
        console.log(18 != 18); // 输出结果：false  (！=不等于)

        // 2.全等 要求 两侧的值 还有 数据类型完全一致
        console.log(18 === 18);// 输出结果：true
        console.log(18 === '18'); //输出结果： false     

等号区别

4.逻辑运算符

用来进行布尔值运算的运算符，其返回值是布尔值。
常用于多个条件的判断。

&& ：一假为假
|| ：一真为真
!：相反的

// 1. 逻辑与 &&  and 两侧都为true  结果才是 true  只要有一侧为false  结果就为false 
        console.log(3 > 5 && 3 > 2); // 输出结果：false
        console.log(3 < 5 && 3 > 2); // 输出结果：true


// 2. 逻辑或 || or  两侧都为false  结果才是假 false  只要有一侧为true  结果就是true
        console.log(3 > 5 || 3 > 2); // 输出结果：true 
        console.log(3 > 5 || 3 < 2); // 输出结果：false

// 3. 逻辑非  not  ！ 
        console.log(!true); // 输出结果：false

短路运算（逻辑中断）

逻辑元素父左边的表达式值可以确定结果时，就不再继续运算右边的表达式的值;

1. 逻辑与
   表达式1 && 表达式2

• 如果第一个表达式的值为真，则返回表达式2
• 如果第一个表达式的值为假，则返回表达式1

     // 1. 布尔值参与的逻辑运算  true && false  == false 
     // 2. 123 && 456  是值 或者是 表达式 参与逻辑运算
     // 3. 逻辑与短路运算  如果表达式1 结果为真 则返回表达式2  如果表达式1为假 那么返回表达式1
        console.log(123 && 456); //输出结果： 456
        console.log(0 && 456); // 输出结果： 0
        console.log(0 && 1 + 2 && 456 * 56789); // 输出结果：0
        console.log('' && 1 + 2 && 456 * 56789); // 输出结果：''
        //存在 0  ''  null undefined  NaN  为假 其余是真的 
       

• 2.逻辑或

  ​ 语法： 表达式1 || 表达式2

  • 如果第一个表达式的值为真，则返回表达式1
  • 如果第一个表达式的值为假，则返回表达式2

        console.log(123 || 456); // 输出结果：123
        console.log(123 || 456 || 456 + 123); //输出结果： 123
        console.log(0 || 456 || 456 + 123); //输出结果： 456
        
        var num = 0;
        console.log(123 || num++);//输出结果：123  num++不执行
        console.log(num); // 输出结果：0
  

5.赋值运算符

数据赋值给变量的运算符。

        var num = 10;
       num = num + 1; //相当于  num++
       console.log(num);// 输出结果：11
       num = num + 2; //相当于   num += 2;
       console.log(num);// 输出结果：13
       num += 5;//相当于   num = num + 5; 
        console.log(num);// 输出结果：18

        var age = 2;
        age *= 3;
        console.log(age);// 输出结果：6

运算符优先级

• 一元运算符里面的逻辑非优先级很高
• 逻辑与比逻辑或优先级高