13-运算符

一、运算符和表达式

运算符：也叫操作符，是一种符号。通过运算符可以对一个或多个值进行运算，并获取运算结果。
表达式：由数字、运算符、变量的组合（组成的式子）。

二、算数运算符

+：当+两边是数字时候，就是算数运算符，只要有一边不是数字，就是连接符
-，*，/
%：取模

• 取模的使用场景--取各位上的数

  <script>
    var num = 567;
    // 个位就是直接对10取模
    var ge = parseInt(num % 10);
    // 十位就是先/10在对10取模
    var shi = parseInt(num / 10 % 10 );
    // 百位就是先/100再对10取模
    var bai = parseInt(num / 100 % 10);
    console.log(`个位${ge}十位${shi}百位${bai}`);//个位7十位6百位5
  </script>

三、一元运算符

必须是变量哦，不然会报错~！

1.前++：++a，最终都会自增1

• 先自增1，再参与运算。先自己发育，再gank

2.后++：a++，最终都会自增1

• 先将变量参与运算再自增1。先去gank，再发育

3.前--和后--同理，都是自减1

    <script>
        var n = 3;
        var m = 5;
        var num1 = n++ + n++ + ++m + n-- - m++;
        // 参与运算的值：  n:3  n:4    m:6     n:5     m:6
        // 自身值：        n:4  n:5    m:6     n:4     m:7

        var a = 4;
        var b = 9;
        var num2 = a++ - b++ + ++b + a++ + ++b + a++;
        // 参与运算的值：a:4   b:9     b:11    a:5     b:12    a:6
        // 自身值：      a:5   b:10    b:11    a:6     b:12    a:7

        console.log(num1);//12
        console.log(num2);//29
    </script>

四、逻辑运算符

返回的一定是布尔类型
包含隐式转换，非布尔类型的值会隐式转为布尔类型

1.逻辑与&&

表达式1 && 表达式2

• 一假则假，只有两边都是true才返回true

逻辑短路：原理就是因为一假则假，代码从做到右执行，当执行到第一个表达式，如果表达式1为假，那么这个返回值一定是假，就睡返回表达式1,；如果表达式1位真，就睡继续往右判断表达式2，所以返回表达式2，因为表达式2的真假决定这的返回值的真假。

当表达式1的值为true，就返回表达式2的值
当表达式1的值为false，就返回表达式1的值

  <script>
    // 逻辑与短路：第一个值为false，后面的代码不会执行
    false && alert('不会执行');

    console.log(1 &&　0);//0
                // true && false => 表达式1的值为真，就直接返回表达式2的值

    console.log(1 && 1 && 2 && 0 &&　0);//0
                //true && true && true && false => 当有2个以上表达时，会返回第一个为false的表达式
  </script>

2.逻辑非||

表达式1 ||表达式2

• 一真则真，只要有一个表达式为真，就返回真

逻辑非短路：原理与逻辑与一致
当表达式1的值为false，就返回表达式1的值
当表达式1的值为true，就返回表达式2的值

    // 逻辑或短路：第一个值为true，后面的代码不会执行
    true || alert('不会执行');

     console.log(1 ||　0);//1
            // true && false => 表达式1的值为真，就直接返回表达式1的值

     console.log(0 || 0 || 2 || 0 ||　0);//2
              //false && false && true && false => 当有2个以上表达时，会返回第一个为true的表达式

3.有一个坑

非布尔值进行逻辑运算，会隐式转为布尔类型去判断， 但是原值不会改变！！！

var result = 5 && 6; // 运算过程：true && true;
console.log('result：' + result); // result：6（也就是说最后面的那个值。）

4.取反

对一个布尔值进行取反。会隐式转换

五、赋值运算符

• = :赋值运算符，将右边的值赋值给左边的 变量 ，左边必须是变量，5 = 5，会报错

• +=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

六、比较运算符

返回的也是布尔类型
也会隐式转换

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

  <script>
    console.log(1 > 2);//false
    // 字符串会转为ASCII编码比较
    console.log('a' > 'A');//true
    // 逐位比较
    console.log('56' > '123');//true
    console.log('小' > '艾');//false
    // 任何值一NaN比较都是false
    console.log(NaN > -9999999);//false

    // ==并不严谨，会做隐式转换，将不同的数据类型，转为相同类型进行比较（大部分情况下，都是转换为数字）
    console.log(1 == '1');//true
    console.log(1 === '1');//false

    // NaN不等于任何东东，包括他本身
    console.log(NaN == NaN);//false

    // undefined 衍生自 null，所以返回true
    console.log(null == undefined);//true
    //全等在比较时，不会做类型转换,开发常用===
    console.log(null === undefined);//false
    
    console.log(3 != 8);	//true
	  console.log(3 != "3");	//false，因为3=="3"是true，所以反过来就是false。
   	console.log(3 !== "3");	//true，应为3==="3"是false，所以反过来是true。
  </script>

七、三元运算符

条件表达式 ? 语句1 : 语句2;
首先判断条件表达式的值：

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

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

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

  <script>
    // 需求：求三个数的最大值
    // 1.获取用户输入内容，并转为Number类型
    var a = +prompt('输入第一个数字');
    var b = +prompt('输入第二个数字');
    var c = +prompt('输入第三个数字');
    // 2.定义一个最大值
    var max;
    // 如果a > b，就将a赋值给max，否则就将b赋值给max
    // 在将max与c比较，如果max小于c就将c赋值给max
    (max = a > b ? a : b) > c ? max : max = c;
    alert(max);
  </script>

八、运算符优先级

优先级从高到低

• ()
• ++、--、!
• *、/
• +、-

• 、>=、<、<=

• 、!=、=、!===
• &&
• ||
• =