• 一元运算符
      • delete
        • delete o.name;
        • delete 运算符不能删除开发者未定义的属性和方法。（我测试发现返回true，但实际未生效）
      • void
        • void 运算符对任何值返回 undefined。
        • 典型案例 （该案例我测试未发现和教程类似，待考证）
      • 前增/减量
        • ++num
          • => num= num+1
        • —num
          • => num = num - 1
      • 后增/减量
        • num++
          • => num= num+1
        • num—
          • => num = num - 1
        • 前增和后增的区别，定义var iNum = 10;
          • var iNum = 10; alert(—iNum); //输出 “9”
          • var iNum = 10; alert(iNum—); //输出 “10”
      • 一元加/减法
        • =+
          • 一元减法就是对数值求正
          • var a = 10; a =+ a; // 输出 10
        • =-
          • 一元减法就是对数值求负
          • var a = 10; a =- a; // 输出 -10
        • 如果是字符串，则会转换为数字

    • 位运算

      • ～（NOT）
        • 处理过程
          1. 把运算数转换成 32 位数字
          2. 把二进制数转换成它的二进制反码
          3. 把二进制数转换成浮点数
        • 实质
          • 对数字求负，然后减 1
          • var a = 10; var b = ~a; alert(b); // 输出 -11

      • & （AND）

        • 对数字的二进制形式进行运算

        • 它把每个数字中的数位对齐，然后用下面的规则对同一位置上的两个数位进行 AND 运算： | 第一个数字中的数位 | 第二个数字中的数位 | 结果 | | —- | —- | —- | | 1 | 1 | 1 | | 1 | 0 | 0 | | 0 | 1 | 0 | | 0 | 0 | 0 |

        • var res = 25 & 3; alert(res); // 输出 1

      • ｜（OR）

        • OR 运算符采用下列规则： | 第一个数字中的数位 | 第二个数字中的数位 | 结果 | | —- | —- | —- | | 1 | 1 | 1 | | 1 | 0 | 1 | | 0 | 1 | 1 | | 0 | 0 | 0 |

      • ^ (XOR)

        • XOR 不同于 OR，当只有一个数位存放的是 1 时，它才返回 1
        • XOR的规则如下： | 第一个数字中的数位 | 第二个数字中的数位 | 结果 | | —- | —- | —- | | 1 | 1 | 0 | | 1 | 0 | 1 | | 0 | 1 | 1 | | 0 | 0 | 0 |

      • << (左移运算)

        • 它把数字中的所有数位向左移动指定的数量

      • (有符号右移运算）

        • 有符号
          • 它把 32 位数字中的所有数位整体右移，同时保留该数的符号（正号或负号）
          • 有符号右移运算符恰好与左移运算相反

      • (无符号右移） 

        1. - 将无符号 32 位数的所有数位整体右移
        2. - 对于正数，无符号右移运算的结果与有符号右移运算一样。
        3. - 负数则被作为正数来处理
    • 逻辑运算符
      • ! (NOT)
        • 行为
          • 如果运算数是对象，返回 false
          • 如果运算数是数字 0，返回 true
          • 如果运算数是 0 以外的任何数字，返回 false
          • 如果运算数是 null，返回 true
          • 如果运算数是 NaN，返回 true
          • 如果运算数是 undefined，发生错误
      • && (AND)
        • 行为
          • true+true => true
          • true+false => false
          • true+false => false
          • false+false => false
        • 逻辑 AND 运算的运算数可以是任何类型的，不止是 Boolean 值
          • 如果一个运算数是对象，另一个是 Boolean 值，返回该对象。
          • 如果两个运算数都是对象，返回第二个对象。
          • 如果某个运算数是 null，返回 null。
          • 如果某个运算数是 NaN，返回 NaN。
          • 如果某个运算数是 undefined，发生错误。
      • || (OR)
        • 行为
          • true+true => true
          • true+false => true
          • true+false => true
          • false+false => false
        • 如果某个运算数不是 Boolean 值，逻辑 OR 运算并不一定返回 Boolean 值
          • 如果一个运算数是对象，并且该对象左边的运算数值均为 false，则返回该对象。
          • 如果两个运算数都是对象，返回第一个对象。
          • 如果最后一个运算数是 null，并且其他运算数值均为 false，则返回 null。
          • 如果最后一个运算数是 NaN，并且其他运算数值均为 false，则返回 NaN。
          • 如果某个运算数是 undefined，发生错误。
    • 四则运算符
        • ：乘法
          • 两数相乘
          • 负负得正，正负得负
          • 特殊处理
            • 如果结果太大或太小，那么生成的结果是 Infinity 或 -Infinity。
            • 如果某个运算数是 NaN，结果为 NaN。
            • Infinity 乘以 0，结果为 NaN。
            • Infinity 乘以 0 以外的任何数字，结果为 Infinity 或 -Infinity。
            • Infinity 乘以 Infinity，结果为 Infinity。
      • / ：除法
        • 用第二个运算数除第一个运算数
        • 负负得正，正负得负
        • 特殊处理
          • 如果结果太大或太小，那么生成的结果是 Infinity 或 -Infinity。
          • 如果某个运算数是 NaN，结果为 NaN。
          • Infinity 被 Infinity 除，结果为 NaN。
          • Infinity 被任何数字除，结果为 Infinity。
          • 0 除一个任何非无穷大的数字，结果为 NaN。
          • Infinity 被 0 以外的任何数字除，结果为 Infinity 或 -Infinity。
      • % ：取余
        • 特殊处理
          • 如果被除数是 Infinity，或除数是 0，结果为 NaN。
          • Infinity 被 Infinity 除，结果为 NaN。
          • 如果除数是无穷大的数，结果为被除数。
          • 如果被除数为 0，结果为 0。
        • ：加法
          • 特殊处理
            • 某个运算数是 NaN，那么结果为 NaN。
            • -Infinity 加 -Infinity，结果为 -Infinity。
            • Infinity 加 -Infinity，结果为 NaN。
            • +0 加 +0，结果为 +0。
            • -0 加 +0，结果为 +0。
            • -0 加 -0，结果为 -0。
          • 字符串相加
            • 如果两个运算数都是字符串，把第二个字符串连接到第一个上。
            • 如果只有一个运算数是字符串，把另一个运算数转换成字符串，结果是两个字符串连接成的字符串。
        • ：减法
          • 特殊处理
            • 某个运算数是 NaN，那么结果为 NaN。
            • Infinity 减 Infinity，结果为 NaN。
            • -Infinity 减 -Infinity，结果为 NaN。
            • Infinity 减 -Infinity，结果为 Infinity。
            • -Infinity 减 Infinity，结果为 -Infinity。
            • +0 减 +0，结果为 +0。
            • -0 减 -0，结果为 -0。
            • +0 减 -0，结果为 +0。
            • 某个运算符不是数字，那么结果为 NaN。
    • 关系运算
      • 常规
        • <

        • =

        • <=
      • 数字与字符串
        • 无论何时比较一个数字和一个字符串，都会把字符串转换成数字，然后按照数字顺序比较它们
        • 字符不能转换成有意义的数字，则会转化为NaN，任何包含 NaN 的关系运算符都要返回 false
          • var bResult = “a” < 3;alert(bResult);
    • 等性运算符
      • ==：等号
        • 为确定两个运算数是否相等，这两个运算符都会进行类型转换
      • !=: 非等号
        • 为确定两个运算数是否相等，这两个运算符都会进行类型转换
        • 类型转换规则
          • 如果一个运算数是 Boolean 值，在检查相等性之前，把它转换成数字值。false 转换成 0，true 为 1。
          • 如果一个运算数是字符串，另一个是数字，在检查相等性之前，要尝试把字符串转换成数字。
          • 如果一个运算数是对象，另一个是字符串，在检查相等性之前，要尝试把对象转换成字符串。
          • 如果一个运算数是对象，另一个是数字，在检查相等性之前，要尝试把对象转换成数字。
      • ===： 全等号
        • 只有在无需类型转换运算数就相等的情况下，才返回 true
          • var sNum = “66”;var iNum = 66;
          • alert(sNum == iNum); //输出 “true”
          • alert(sNum === iNum); //输出 “false”
      • !==： 非全等号
        • 只有在无需类型转换运算数不相等的情况下，才返回 true。
      • 等号，非等号，全等号，非全等号
        • 等号和非等号用于处理原始值，全等号和非全等号用于处理对象
      • 特殊情况处理
        • null == undefined true
        • “NaN” == NaN false
        • 5 == NaN false
        • NaN == NaN false
        • NaN != NaN true
        • false == 0 true
        • true == 1 true
        • true == 2 false
        • undefined == 0 false
        • null == 0 false
        • “5” == 5 true
    • 条件运算符
      • 三目运算
        • variable = boolean_expression ? true_value : false_value;