JS运算符分：逻辑运算符 和 算术运算符

    基本四则运算
    加法运算符
    作用：

    • 数学运算，如1+2 = 3
    • 字符串连接，如'a'+'b' = 'ab'
    • 字符串转换，如何数据类型+字符串类型 都等于 字符串，如1+'a'='1a'

    其他仅用于数运算的运算符

    • 减法运算符，如 1-1 = 0
    • 乘法运算符，如 1*0 = 0
    • 除法运算符，如 1/1 = 0
    • 求模运算符，如 1%5 = 1

    自加（++）与自减（—）

    • 后加（a++），先加（++a）
    • 后减（a—），先减（—a） ```javascript var a=1; console.log(a++); //输出1，先输出再做加法运算

    var b=1; console.log(++b); //输出2，先做加法运算再输出

    var c=1; console.log(c—); //输出1，先输出再做减法运算

    var d=1; console.log(—d); //输出0，先做减法运算再输出

    2. 算术运算的一些简化写法
    3. ```javascript
    4. var a = 1;
    5. a += 1; // 等价于a = a + 1
    6. a -= 1; // 等价于a = a - 1
    7. a *= 1; // 等价于a = a * 1
    8. a /= 1; // 等价于a = a / 1
    9. a %= 1; // 等价于a = a % 1

    加法运算符
    1、数值运算
    2、连接字符串

    加法运算步骤：
    1、如果运算值为对象，先进行类型转换为原始类型的值（先进行valueOf，如果不是原始类型的值，再进行toString；如果是Date，直接进行toString）
    2、都转换成原始类型后：原始类型+原始类型，其中一个是string，另外一个则转换为string
    3、如果不是string，转换为数值，在进行加法运算
    实例：
    ‘1’ + {foo: ‘bar’} // “1[object Object]”
    ‘1’ + 1 // “11”
    ‘1’ + true // “1true”
    ‘1’ + [1] // “11”

    注意，字符串的位置不同，加法产生的结果也将不同
    ‘3’ + 4 + 5 // “345”
    3 + 4 + ‘5’ // “75”

    由于此特性，可以通过 x+’’将一个数值转换为string

    如果加号的左边无数值，右边有数值，此时加法变为“数值运算符”，结果返回的是右边数据的数值形式
    + - 3 // 等同于 +(-3)
    + 1 + 2 // 等同于 +(1 + 2)
    + ‘1’ // 1

    注意：如果加号右边无数值，只有左边有数值，此时被当作语法错误。
    1 +
    // SyntaxError: Unexpected end of input

    减法、乘法、除法都只能用于数值运算
    例如，在日期计算时
    var now = new Date();
    typeof (now + 1) // “string”
    typeof (now - 1) // “number”

    余数运算 %
    可用与正数 和 负数

    数值运算符（+）
    +true // 1
    +[] // 0
    +{} // NaN

    赋值运算符
    x += y // 等同于 x = x + y
    x -= y // 等同于 x = x - y
    x = y // 等同于 x = x y
    x /= y // 等同于 x = x / y
    x %= y // 等同于 x = x % y
    x >>= y // 等同于 x = x >> y
    x <<= y // 等同于 x = x << y
    x >>>= y // 等同于 x = x >>> y
    x &= y // 等同于 x = x & y
    x |= y // 等同于 x = x | y
    x ^= y // 等同于 x = x ^ y

    比较运算
    == 相等
    === 严格相等
    != 不相等
    !== 严格不相等
    < 小于
    <= 小于或等于
    > 大于
    >= 大于或等于
    在比较字符串的时候，是根据字符串首字母的unicode码点进行比较，因此也适用于汉字
    ‘cat’ > ‘dog’ // false
    ‘cat’ > ‘catalog’ // false
    特殊情况，如何值与NaN比较，都返回NaN

    注意，日期比较，先toString，再valueOf

    **严格相等===比较**
    1、原始类型比较数值
    2、复合类型指向内存引用地址，因此比较的是地址是否相等
    3、NaN不严格相等
    4、null和undefined自身严格相等
    5、Date类型比较的是地址

    **相等==比较**

    1. 比较相同数据类型时，与严格相等一样，先进行类型转换，再进行严格相等
    2. 原始类型先转换成数值，再 进行比较

    1 == true // true
    // 等同于 1 === 1

    0 == false // true
    // 等同于 0 === 0

    2 == true // false
    // 等同于 2 === 1

    2 == false // false
    // 等同于 2 === 0

    ‘true’ == true // false
    // 等同于 Number(‘true’) === Number(true)
    // 等同于 NaN === 1

    ‘’ == 0 // true
    // 等同于 Number(‘’) === 0
    // 等同于 0 === 0

    ‘’ == false // true
    // 等同于 Number(‘’) === Number(false)
    // 等同于 0 === 0

    ‘1’ == true // true
    // 等同于 Number(‘1’) === Number(true)
    // 等同于 1 === 1

    ‘\n 123 \t’ == 123 // true
    // 因为字符串转为数字时，省略前置和后置的空格

    1. 复合类型与原始类型比较，先转换成原始类型再进行比较

    2. undefined和null与其他类型比较都为false，undefined==null则返回true


      布尔运算符
      取反运算符：!
      有以下值取反后为true
      undefined
      null
      false
      0（包括+0和-0）
      NaN
      空字符串（’’）

      且运算符：&&
      运算规则：
      第一个表达式的值返回true，则返回第二条表达式的值
      第一条表达式的值返回false，则返回第一条表达式的值
      多个连用的情况下，返回第一个值为false的运算，不再执行后面的且预算
      ‘foo’ && 0 && true
      执行到0处，则结束这个表达式的运算，因为0==>false

      或运算符：||
      第一个表达式的值返回true，则返回第一条表达式的值
      第一条表达式的值返回false，则返回第二条表达式的值

      三元运算符：?:

      位运算符（略）

      void运算符
      执行表达式，却不返回任何值，即返回undefined
      void 0 => undefined
      void(0) => undefined
      优先级别高
      void 4 + 7 引擎解析成 (void + 4) + 7

      逗号运算符：
      用于对两个表达式的求值，然后返回最后一个表达式的值
      ‘a’ , ‘b’ => 返回’b’

      运算符优先级
      逻辑运算符优先级
      <= ，=== ，|| ，?: ，=

      四则运算符的优先级别按照数学运算的逻辑

      圆括号：
      用于提高运算优先级，但它不是运算符，而是一种语法结构
      圆括号中不能进行赋值和变量定义的操作