想学js的看过来 ---- js的运算符

1. js的算数运算符 ： + - * / %

    // console.log(1 + 2)  // 3
    // console.log(1 + '2')    // 12
   
    // console.log(2 - 2)  // 0
    // console.log(2 - '2')  // 2 - '2'    --> 2 -2    == 0
   
    // console.log(1 * 3)  // 3
    // console.log(1 * '3')  // 1 * '3'    --> 1 * 3   == 3
   
    // console.log(3 / 1)  // 3
    // console.log(3 / '1')  // 3 / '1'    --> 3 / 1   == 3
   
    // console.log(7 % 2)  // 1
    // console.log(7 % '2')  // 7 % '2'    --> 7 % 2   == 1
   
    var a = 1 + 2 * (1 + 2)
        /**
         * 1 + 2 * 3
         * 1 + 6
         * 7
        */
    console.log(a)
   

2. js的赋值运算符： += -= *= /= %=

   var a = 1
   
   // a = a + 1
   // 我自身   赋值为   我自身 + 1
   // a += 1  // a = a + 1
   
   // a += 10 // a = a + 10   ---> a == 1         a = 1 + 10      a == 11 
   
   // a = a - 1   // 我自身   赋值为  我自身    -   1
   // a -= 1  // 0
   
   // a = a * 2   // 2
   // a *= 2  // 2
   
   // a = a / 1   // 1
   // a /= 1  // 1
   
   // a =  a % 1  // 0
   // a %= 1  // 0
   
   console.log(a)
   

3. js的比较运算符：> < >= <= == === != !==

      // console.log(1 > 2)  // false
      // console.log(1 < 2)  // true
      // console.log(2 >= 2)  // true
      // console.log(2 <= 2)  // true
   
      /**
       * ==   等于
       * =    赋值
       * ===  全等
       * 
       * == 和 === 作用一样, 用于对比两侧数据是否相等
       *      == 只对比数据, 不对比数据类型
       *      === 对比数据, 且 对比数据类型
       * 
       * == 在对比数据时, 两侧数据不同, 比如 一侧时数字, 一侧时字符串, 会进行隐式转换
      */
      // console.log(2 == 2) // true
      // console.log(2 === 2) // true
      // console.log(2 == '2') // true
      // console.log(2 === '2') // false
   
      /**
       * !=   不等于
       * !==  不全等于
       * 
       * 两者作用相同, 用于对比两侧数据是否相同, 相同时返回 false, 不相同返回 true
       *      != 只对比数据, 不对比数据类型   (会进行隐式转换, 转换为相同类型在对比)
       *      !== 对比数据, 且 对比数据类型
      */
   
      // console.log(2 != 2) // false
      // console.log(2 !== 2) // false
      console.log(2 != '2') // false
      console.log(2 !== '2') // true
   

4. js的逻辑运算符： && (逻辑与 逻辑且) || (逻辑或) ! (非, 取反, 逻辑非)

        /**
   * 逻辑与
   *
   *  语法:
   *      变量1 && 变量2
   *      表达式1 && 表达式2
   *
   *  返回方式:
   *      前一个为真, 就返回后一个
   *      前一个为假, 就返回第一个
   */
       // var bo = 1 && 0
      // /**
      //  * var bo = 1 && 0
      //  *  逻辑与 左侧 1 右侧 0
      //  *      1 转为布尔值 会转为 ture (非0即为真)
      //  *  按照逻辑与的返回方式
      //  *      前一个为真, 会返回后一个
      //  * 所以此时 bo 的值为 0
      // */
      // console.log(bo)  // 0
   

逻辑或

   // var bo = 1 || 0
        /**
         * 逻辑或 左侧 1 右侧 0
         *      1 转为布尔值 转为true (非0即为真)
         *  按照逻辑或的返回方式
         *      前一个为真(左侧为真), 返回左侧
         *      前一个为假(左侧为假), 会返回右侧(后一个, 第二个)
         * 
         * 所以此时符合第一条返回规则, 所以bo的值 为 1
        */
        // console.log(bo) // 1

逻辑非

    // var bo = true
    // console.log(bo)  // true
    // console.log(!bo)  // false

    // var bo1 = 0
    // console.log(bo1) // 0
    // console.log(!bo1) // 0 转为布尔值为false, false经过取反为true, 所以打印true

    // var bo2 = 1
    // console.log(!bo2)   // 1 转为布尔值为true, true经过取反为false, 所以打印false

    var bo = 1
    console.log(typeof bo)  // number
    console.log(typeof !bo)  // false
    console.log(typeof !!bo)  // true
    /**
     * bo 的值为 1
     * !bo  --> false
     * !!bo --> true
    */