JS 运算符

• 就是在代码李进行运算的时候使用的符号，不过只是数学运算，我们在js里面还有很多的运算方式

0. 数学运算符

   • +， - ， * ， / ，%

• • 只有符号两边都是数字的时候才会进行加法运算

  • 只要符号任意一变是字符串，就会进行字符串拼接

    var a=100
    var b=200
    var c=a+b 
    ​
    

• • 回执行减法运算

  • 会自动把两边都转换成数字惊醒运算

• • 会执行乘法预算
  • 会自动把两边都转换成数字进行运算

• /

  • 会执行除法运算
  • 会自动把两边都转换成数字进行运算

• %

  • 会执行取余运算
  • 会自动把两边都转换成数字进行运算

2. 赋值运算符

   0. =

      • 就是把 = 右边的赋值给等号左边的变量名

        var num = 100  //就是把100赋值给变量num， 变量num的值就是100
        

   1. +=

      var a =10
      a += 10
      console.log(a)   //变量a的值变为20
      //等价于a=a+10
      

   2. -=

      var a = 20
      a -= 10
      console.log(a)   //变量a的值变为10
      //等价于 a=a-10
      

   3. *=

      var a = 20
      a *= 10
      console.log(a)   //变量a的值变为200
      //等价于 a=a*10
      

   4. /=

      var a = 20
      a /= 10
      console.log(a)   //变量a的值变为2
      //等价于 a=a/10
      

   5. %=

      var a = 10
      a %= 3
      console.log(a)   //变量a的值变为1
      //等价于 a=a%3
      

3. 比较运算符

   0. ==

      • 1 == ‘1’

      • 比较符号两边的值是否相等，不管数据类型

        两个的值是一样的，所以等到true

   1. ===

      • 1 === ‘1’

      • 比较符号两边的值和数据类型是否都相等

        //两个等号与三个等号的去呗
          == 在js中判断时会左隐式转换，也就是说，指挥对比值是否相等，不会对比数据类型
          === 在js中也叫全等，在判断的时候不会做隐式转换，也就是说，在对比时出来会对比值是否相等，还会判断数据类型
        

   2. !=

      • 比较符号两边的值是否不等 * 1 != '1' * 因为两边的值是相等的，所以比较他们不等的时候得到false

   3. !==

      • 比较符号两边的数据类型和值是否不等

        1 != '1'

        因为两边的数据类型不一样，所以得到true

   4. =

      • 比较左边的值是否大于或等于右边的值

        1>=-1  结果是true
        
        ​	1>=0 结果是true
        
        ​    1>=2 结果是false
        

   5. <=

      • 比较左边的值是否小于或等于右边的值

        	 1<=-1  结果是false
        
        ​	 1<=0 结果是false
        
        ​    1<=2 结果是true
        

   6. • 比较左边的值是否大于右边的值

         1>-1  结果为true
        
        ​     1>2  结果为fales
        

   7. <

      • 比较左边的值是否小于右边的值

        ~~~js
        1<-1  结果为false
        
        ​     1<2  结果为true
        ~~~
        

4. 逻辑运算符

   • && ， || ,

     0. && 进行且运算

        • 符号的左边为true并且右边也是true，才会返回true

        • 只要一边不是true，那么就会返回false

          ~~~js
          true  && true     结果为true
          true  && false     结果为false
          false  && true    结果为false
          false && false    结果为false
          

        逻辑与的特性
          符号左边的值，如果为真，（也就是转为布尔值后true）那么会返回符号右边的值，如果为假，（也就时布尔值为false），那么会将自身返回出去
          console.log(1 && 100) //返回值为100
          console.log(0 && 99）返回值为0
        

     1. || 进行或的运算

        • 符号左边为true或右边为true ，都会返回true

        • 只有两边都是false 才会返回false

          true  && true     结果为true
          true  && false     结果为true
          false  && true    结果为true
          false && false    结果为false
          

3.！ 进行取反运算（写在操作数之前）

本身是true的，会变成flase

本身是flase的，回变成true

                                     !ture========>结果为false
                                     !false========>结果为true
                       

特殊：

          
               1.   !!a  =====>转换为布尔值
               2.   &&  ||   短路 用法  
               //如果 flase&& true  左边已经为假，所以不在运算
                // 如果 true || flase  前面已经为真，所以后面不在运算
               //也就是前面为真后面不在运算
         

5. 自增自减运算符

   • ++, --

     1.++

     • 进行自增运算

     • 分成两种， 前置++ 和 后置++

     • 前置++ ，会自动先把值自动加1，在返回

       var a = 10
       console.log(++a) //会返回11，a的值变为11
       //先进行+1，再返回a的值
       

     • 后置++ ，会先把值返回，在自动加1

       var a = 10
       console.log(a++)  //先返回的值为10，之后在进行a+1，a的值为11
       //先返回a的值，再进行+1的运算
       

   2. --

      • 进行自减运算

      • 分成两种， 前置-- 和 后置--

      • 和++ 运算符的道理一样

      • 前置 --

        var a = 10
        console.log(--a) //返回的值为9 ，a的值变为9
        //先进行-1运算，在返回a的值
        

      • 后置--

        var a = 10
        console.log(a--) //返回的值为10 ，a的值变为9
        //先返回a的值，在进行-1运算
        

6. 三目运算符（三元运算符）

   • 三元运算，即使用两个符号组成一个语句

   • 语法 ： 条件 ？条件为true的时候执行：条件为false的时候执行

     var age = 18
     age >= 18 ?arlert('已经成年'):alert('没有成年')
     //如果age大于或者等于18 就执行第一个alert，弹出已成年，否则显示没有成年
     //也就是如果满足条件就执行第一条语句，否者执行第二条
     //条件 ？ 第一条语句:第二条语句 
     //多次引用三目运算符   
     var a =230
     a > 200 ? a-10 : (a>100?a-5:a) //如果a大于200执行第一条语句a-10，否者执行第二条语句如果a>100,则执行第二条语句中的第一条，否者执行其中的第二条
     

7. 运算符的优先级

   运算符优先级从高到低

   自增自减运算符++ -- ! 算术运算符 先* / % 后+ - 比较运算符中的 > >= < <= 比较运算符中的 == != === !== 逻辑运算符 先&& 后|| 赋值运算符