JavaScript——操作符

1. 一元操作符

只能操作一个值的操作符叫做一元操作符

递增和递减操作符 ++ --

递增和递减操作符有两个版本:前置型和后置型

• 前置递增和递减: 递增和递减操作是在包含它们的语句被求值之前才执行的
• 后置递增和递减: 递增和递减操作是在包含它们的语句被求值之后才执行的

在应用于不同的值时，递增和递减操作符遵循下列规则:
( 递增和递减操作符对任何值都适用，也就是它们不仅适用于整数，还可以用于字符串、布尔值、浮点数值和对象，会改变操作数的数值类型 )

• 在应用于包含有效数字的字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量。
• 在应用于一个不包含有效数字字符的字符串时，将变量的值设置为NaN。字符串变量变成数值变量。
• 在应用于布尔值 false时，先将其转换为0再执行加减1的操作。布尔值变量变成数值变量
• 在应用于布尔值 true时，先将其转换为1再执行加减1的操作。布尔值变量变成数值变量
• 在应用于数值（整数和浮点数）时，执行加减 1 的操作。
• 在应用于对象时，先调用对象的valueOf()方法以取得一个可供操作的值。然后对该值应用前述规则。如果结果是NaN，则在调用toString()方法后再应用前述规则。对象变量变成数值变量。
• 对于变量值为undefined，++/-- 输出NaN
• 对于变量值为null，++/-- null转换为0，再执行加减1操作

var s1 = "2";
var s2 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf: function() {
        return -1;
    }
};
var u;
var n = null;
s1++; // 值变成数值3  数据类型由string变成为number
s2++; // 值变成NaN  数据类型由string变成为number
b++; // 值变成数值1  数据类型由Boolean变成为number
f--; // 值变成 0.10000000000000009（由于浮点舍入错误所致） 数据类型number不改变
o--; // 值变成数值-2  数据类型由object变成为number
u++; // 值变成NaN  数据类型由undefined变成为number
n++; // 值变成1  数据类型由null变成为number
复制代码

一元加法、减法操作符 + -

一元加法、减法操作符作用

• 基本加减法算术运算
• 用于转换数据类型

一元加法操作符 +

1. 用于一元加法运算

• 放在数值前面，对数值不会产生任何影响

var iNum = 20;
iNum = +iNum;
alert(iNum);	//输出 "20"
复制代码

2. 用于转换数据类型

• 在对非数值应用一元加操作符时，该操作符会像Number()转型函数一样对这个值执行转换，把非数值转换成数字类型。

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf: function() {
        return -1;
    }
};
var u;
var n = null;
s1 = +s1; // 值变成数值 1 数据类型由string变成为number
s2 = +s2; // 值变成数值 1.1 数据类型由string变成为number
s3 = +s3; // 值变成 NaN 数据类型由string变成为number
b = +b; // 值变成数值 0 数据类型由Boolean变成为number
f = +f; // 值未变，仍然是 1.1 数据类型number
o = +o; // 值变成数值-1 数据类型由object变成为number
u = +u; // 值变成NaN  数据类型由undefined变成为number
n = +n; // 值变成0  数据类型由null变成为number
复制代码

一元减操作符 -

1. 用于一元减法运算

• 一元减操作符应用于数值时，该值会变成负数

var iNum = 20;
iNum = -iNum;
alert(iNum);	//输出 "-20"
复制代码

2. 用于转换数据类型

• 应用于非数值时，该操作符会像Number()转型函数一样对这个值执行转换，最后再将得到的数值转换为负数，把非数值转换成数字类型

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var o = {
    valueOf: function() {
        return -1;
    }
};
var u;
var n = null;
s1 = -s1; // 值变成了数值-1
s2 = -s2; // 值变成了数值-1.1
s3 = -s3; // 值变成了 NaN
b = -b; // 值变成了数值 0
f = -f; // 变成了-1.1
o = -o; // 值变成了数值 1
u = -u; // 值变成NaN  数据类型由undefined变成为number
n = -n; // 值变成0  数据类型由null变成为number
复制代码

2. 加性操作符 + -

加法

1. 如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：
   （ 两个操作符都是数值，+ 相当于加法算术运算符 ）
   • 如果有一个操作数是 NaN ，则结果是 NaN ；
   • 如果是 Infinity 加 Infinity ，则结果是 Infinity ；
   • 如果是 -Infinity 加 -Infinity ，则结果是 -Infinity ；
   • 如果是 Infinity 加 -Infinity ，则结果是 NaN ；
   • 如果是 +0 加 +0，则结果是 +0；
   • 如果是 -0 加 -0，则结果是 -0；
   • 如果是 +0 加 -0，则结果是 +0。

var result1 = 5 + 5; // 两个数值相加
alert(result1); // 10
复制代码

2. 如果参与计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。(如果操作数里有字符串先以下面的规则为准则)

3. 如果有一个操作数是字符串，根据下列规则返回结果：
   （注： 此时的 + 成为 字符串连接操作符）

• 如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来
• 如果只有一个操作数是字符串，则将另一个非字符串的操作数转换为字符串，然后再将两个字符串拼接起来。
  • 如果只有一个字符串，且另一个操作数是对象、数值、布尔值，则调用他们的toString()方法取得相应的字符串值，然后再应用前面的字符串的规则。
  • 如果只有一个字符串，且另一个操作数是undefined、null，则分别调用String()函数将他们转化为 "undefined"和"null"，然后再应用前面的字符串的规则。

console.log(1+1)            //2
console.log(1+NaN)          //NaN
console.log(1+true)         //2
console.log(false+true)     //1
console.log("str"+"56")     //str56
console.log("str"+56)       //str56
console.log("str"+{a:1})    //str[object Object]
console.log("str"+null)     //strnull
console.log("str"+undefined)//strundefined
复制代码

减法

1. 如果两个操作符都是数值，执行常规的减法计算，然后根据下列规则返回结果：
   （ 两个操作符都是数值，- 相当于减法算术运算符 ）
   • 如果有一个操作数是 NaN ，则结果是 NaN ；
   • 如果是 Infinity 减 Infinity ，则结果是 NaN；
   • 如果是 -Infinity 减 -Infinity ，则结果是 NaN ；
   • 如果是 Infinity 减 -Infinity ，则结果是 Infinity ；
   • 如果是 -Infinity 减 Infinity ，则结果是 -Infinity ；
   • 如果是 +0 减 +0，则结果是 +0；
   • 如果是 -0 减 -0，则结果是 +0；
   • 如果是 +0 减 -0，则结果是 -0。
2. 如果参与计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。(如果有下面特殊情况，以下面的规则为准则)
3. 如果有一个操作数是字符串、布尔值、 null 或 undefined ，则先在后台调用Number() 函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是NaN，则减法的结果就是 NaN ；
4. 如果有一个操作数是对象，则调用对象的valueOf()方法以取得表示该对象的数值。如果得到的值是 NaN ，则减法的结果就是NaN。如果对象没有valueOf()方法，则调用其toString()方法并将得到的字符串转换为数值。

var result2 = NaN - 1; // NaN
var result3 = 5 - 3; // 2
var result4 = 5 - ""; // 5，因为"" 被转换成了 0
var result5 = 5 - "2"; // 3，因为"2"被转换成了 2
var result1 = 5 - true; // 4，因为 true 被转换成了 1
var result5 = 5 - undefined; // NaN，因为undefined被转换成了NaN
var result6 = 5 - null; // 5，因为 null 被转换成了 0
复制代码

注：一元加法操作符和加性操作符加法的区别：

一元加法操作符：

• 是一元加法运算 如 n = +n
• 改变操作数的数据类型

加性操作符的加法：

• 是两元（多元）加法运算 如 n = a + b
• 不改变操作数的数据类型

3. 乘性操作符 * / %

乘法

乘法操作符由一个星号（ * ）表示，用于计算两个数值的乘积。

乘法操作符遵循下列特殊的规则：

1. 如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了ECMAScript数值的表示范围，则返回 Infinity 或 -Infinity ；

• 如果有一个操作数是 NaN ，则结果是 NaN ；
• 如果是 Infinity 与 0 相乘，则结果是 NaN ；
• 如果是 Infinity 与非0数值相乘，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
• 如果是 Infinity 与 Infinity 相乘，则结果是 Infinity ；

2. 如果有一个操作数不是数值，则非数值调用Number()将其转换为数值，然后再应用上面的规则。

console.log(12 * 56)        //672
console.log(12 * "")        //0
console.log(12 * "str")     //NaN
console.log(12 * true)      //12
console.log(12 * null)      //0
console.log(12 * undefined) //NaN
console.log(12 * {a:1})     //NaN
console.log(12 * NaN)       //NaN
复制代码

除法

除法操作符由一个斜线符号（/）表示，执行第二个操作数除第一个操作数的计算

除法操作符遵循下列特殊的规则：

1. 如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果商超过了ECMAScript数值的表示范围，则返回 Infinity 或 -Infinity ；

• 如果有一个操作数是 NaN ，则结果是 NaN ；
• 如果是 Infinity 被 Infinity 除，则结果是 NaN ；
• 如果是零被零除，则结果是 NaN ；
• 如果是非零的有限数被零除，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
• 如果是 Infinity 被任何非零数值除，则结果是Infinity或-Infinity，取决于有符号操作数的符号；

2. 如果有一个操作数不是数值，则非数值调用Number()将其转换为数值，然后再应用上面的规则。

console.log(12 / 3)         //4
console.log(12 / "")        //Infinity
console.log(12 / "str")     //NaN
console.log(12 / true)      //12
console.log(12 / null)      //Infinity
console.log(12 / undefined) //NaN
console.log(12 / {a:1})     //NaN
console.log(12 / NaN)       //NaN
复制代码

求模

求模（余数）操作符由一个百分号（ % ）表示

求模操作符遵循下列特殊的规则：

1. 如果操作数都是数值，执行常规的除法计算，返回除得的余数；

• 如果被除数是无穷大值而除数是有限大的数值，则结果是 NaN ；
• 如果被除数是有限大的数值而除数是零，则结果是 NaN ；
• 如果是 Infinity 被 Infinity 除，则结果是 NaN ；
• 如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数；
• 如果被除数是零，则结果是零；

2. 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

4. 布尔操作符

逻辑非（NOT）

逻辑非操作符由一个叹号（！）表示

1. 逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。逻辑非操作符一定会返回一个布尔值。

   逻辑非操作符遵循下列规则：

   • 如果操作数是一个对象，返回 false ；
   • 如果操作数是一个空字符串，返回 true ；
   • 如果操作数是一个非空字符串，返回 false ；
   • 如果操作数是数值 0，返回 true ；
   • 如果操作数是任意非 0 数值（包括 Infinity ），返回 false ；
   • 如果操作数是 null ，返回 true ；
   • 如果操作数是 NaN ，返回 true ；
   • 如果操作数是 undefined ，返回 true 。

   alert(!false); // true
   alert(!"blue"); // false
   alert(!0); // true
   alert(!NaN); // true
   alert(!""); // true
   alert(!12345); // false
   复制代码

2. 逻辑非操作符可以用于将一个值转换为与其对应的布尔值。
   同时使用两个逻辑非操作符，实际上就会模拟 Boolean()转型函数的行为。其中，第一个逻辑非操作会基于无论什么操作数返回一个布尔值，而第二个逻辑非操作则对该布尔值求反，于是就得到了这个值真正对应的布尔值。

   alert(!!"blue"); //true
   alert(!!0); //false
   alert(!!NaN); //false
   alert(!!""); //false
   alert(!!12345); //true
   复制代码

逻辑与（AND）

逻辑与操作符由两个和号（ && ）表示，有两个操作数

1. 操作数都是布尔值，返回一定是布尔值
   根据逻辑与&&的真值表

   第一个操作数	第二个操作数	结果
   true	true	true
   true	false	false
   false	true	false
   false	false	false

2. 在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值

   当逻辑运算两侧不都是布尔值参与时，会将其他数据隐式转换为布尔值。

   • 隐式转为false：0，“”, NaN, undefined, null
   • 隐式转为true: 非0数字（Infinity），非空字符串

   根据逻辑与&&的短路语法（串联电路）：
   

   • 如果第一个操作数是 false ，则无论第二个操作数是什么值，结果都不再可能是 true
   • 遇到false 返回 值是false的操作数

   4 && "hello"  //返回 “hello”
   复制代码

逻辑或（OR）

逻辑或操作符由两个竖线符号（ || ）表示，有两个操作数

1. 操作数都是布尔值，返回一定是布尔值
   根据逻辑或||的真值表

   第一个操作数	第二个操作数	结果
   true	true	true
   true	false	true
   false	true	true
   false	false	false

2. 在有一个操作数不是布尔值的情况下，逻辑或操作就不一定返回布尔值

   当逻辑运算两侧不都是布尔值参与时，会将其他数据隐式转换为布尔值。

   • 隐式转为false：0，“”, NaN, undefined, null
   • 隐式转为true: 非0数字（Infinity），非空字符串

   根据逻辑或||的短路语法（并联电路）：
   

   • 如果第一个操作数的求值结果为true ，就不会对第二个操作数求值
   • 遇到true 返回 值是true的操作数

   4 || "hello"  //返回 4
   复制代码

3. 利用逻辑或的这一行为来避免为变量赋 null 或 undefined 值

   var myObject = preferredObject || backupObject;
   复制代码

逻辑运算符的执行顺序：

① 非 ② 与 ③ 或 （结合真值表和逻辑短路语法）

false || !false && false || true;
=  false || true && false || true
= false || false || true
= false || true
= true
复制代码

4 && "hello" || !false || !true && null;
= 4 && “hello”  || true || false && null
= “hello” || true || false
= “hello” || false
= “hello”
复制代码

5. 关系操作符

小于（<）、大于（>）、小于等于（<=）和大于等于（>=）

相应的规则：

• 如果两个操作数都是数值，则执行数值比较。
• 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值
  （字符编码顺序从小到大：数字 < 大写字母 < 小写字母 < 中文）。
• 如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。
• 如果一个操作数是对象，则调用这个对象的valueOf()方法，用得到的结果按照前面的规则执行比较。如果对象没有valueOf()方法，则调用toString()方法，并用得到的结果根据前面的规则执行比较。
• 如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
• 任何操作数与 NaN 进行关系比较，结果都是 false

var result = 23 < 3;                //false
var result = "Brick" < "alphabet";  //true
var result = "23" < "3";            //true
var result = "23" < 3;              //false 
console.log({a:1} < 3)              //false，因为{a:1}被转换成了 NaN
console.log(true < 3)               //true
var result = "a" < 3;               //false，因为"a"被转换成了 NaN
复制代码

6. 相等操作符

等于（==）、不等于（!=）、全等于（===）和不全等于（!==）

相等和不相等 == / !=

先转换操作数（通常称为强制转型），然后再比较它们的相等性

在转换不同的数据类型时，相等和不相等操作符遵循下列基本规则：

• 如果一个运算数是 Boolean 值，在检查相等性之前，把它转换成数字值。false 转换成 0，true 为 1。
• 如果一个运算数是字符串，另一个是数字，在检查相等性之前，要尝试把字符串转换成数字。
• 如果一个运算数是对象，另一个是字符串，在检查相等性之前，要尝试把对象转换成字符串。
• 如果一个运算数是对象，另一个是数字，在检查相等性之前，要尝试把对象转换成数字。
• 如果一个操作数是对象，另一个操作数不是对象，则调用对象的valueOf()方法，用得到的基本类型值按照前面的规则进行比较

这两个操作符在进行比较时则要遵循下列规则:

• 值 null 和 undefined 相等。
• 在检查相等性时，不能把 null 和 undefined 转换成其他值。
• 如果某个运算数是 NaN，等号将返回 false，非等号将返回 true。
  即使两个数都是 NaN，等号仍然返回 false，因为根据规则，NaN 不等于 NaN。
• 如果两个运算数都是对象，那么比较的是它们的引用值。如果两个运算数指向同一对象，那么等号返回 true，否则两个运算数不等。

true == 1               //true
null == undefined       //true  
"NaN" == NaN            //false  
true == 2               //false
5 == NaN                //false  
undefined == 0          //false
NaN == NaN              //false  
null == 0               //false  在检查相等性不能把 null转换成其他值
NaN != NaN              //true  
"5"==5                  //true
false == 0              //true
复制代码

全等号和非全等号 === / !==

全等操作符由 3 个等于号（ === ）表示，它只在两个操作数未经转换就相等的情况下返回 true

不全等操作符由一个叹号后跟两个等于号（!==）表示，它在两个操作数未经转换就不相等的情况下返回 true

var result1 = ("55" != 55); //false，因为转换后相等
var result2 = ("55" !== 55); //true，因为不同的数据类型不相等
复制代码

null == undefined 会返回 true ，因为它们是类似的值；但 null === undefined 会返回 false ，因为它们是不同类型的值

7. 赋值操作符

简单的赋值操作符由等于号（ = ）表示，其作用就是把右侧的值赋给左侧的变量

var num = 10;
复制代码

如果在等于号（ = ）前面再添加乘性操作符、加性操作符或位操作符，就可以完成复合赋值操作。

//这种复合赋值操作相当于是对下面常规表达式的简写形式：
var num = 10;
num = num + 10;
//其中的第二行代码可以用一个复合赋值来代替：
var num = 10;
num += 10;
复制代码

每种主要的算术运算以及其他几个运算都有复合赋值运算符：

• 乘法/赋值（*=）
• 除法/赋值（/=）
• 取模/赋值（%=）
• 加法/赋值（+=）
• 减法/赋值（-=）
• 左移/赋值（<<=）
• 有符号右移/赋值（>>=）
• 无符号右移/赋值（>>>=）

8. 条件操作符

条件运算符是 ECMAScript 中功能最多的运算符，它的形式与 Java 中的相同。

variable = boolean_expression ? true_value : false_value;

该表达式主要是根据 boolean_expression的计算结果有条件地为变量赋值。如果Boolean_expression 为 true，就把true_value赋给变量；如果它是false，就把false_value赋给变量。

var iMax = (iNum1 > iNum2) ? iNum1 : iNum2;
//在这里例子中，iMax 将被赋予数字中的最大值。表达式声明如果 iNum1 大于 iNum2，则把 iNum1 赋予 iMax。但如果表达式为 false（即 iNum2 大于或等于 iNum1），则把 iNum2 赋予 iMax。
复制代码

9. 逗号操作符

用逗号运算符可以在一条语句中执行多个运算。

//逗号运算符常用变量声明中。
var iNum1 = 1, iNum = 2, iNum3 = 3;
复制代码

综合运算

综合运算顺序：贴身的（! ++ --）→ 数学运算 → 比较运算 → 逻辑运算 → 赋值运算

计算：
    var a = 4;
    var sum = 1 * (2 + 3) && a++ || 5 > 6 && 7 < 8 || 9;
    console.log(sum);

    sum = 1 * (2 + 3) && a++ || 5 > 6 && 7 < 8 || 9
        =  1 * (2 + 3) && 4 || 5 > 6 && 7 < 8 || 9
        = 5 && 4 || 5 > 6 && 7 < 8 || 9
        = 5 && 4 || false && true || 9
        = 4 || false || 9
        = 4 || 9
        = 4 
练习：
    var a = 4;
    1 + 2 && 3 * a++ % 5 || 6 < 7 == 8 / !false
    
    1 + 2 && 3 * a++ % 5 || 6 < 7 == 8 / !false
    = 1 + 2 && 3 * 4 % 5 || 6 < 7 == 8 / true
    = 3 && 2 || 6 < 7 == 8
    = 3 && 2 || true == 8
    = 3 && 2 || false
    = 2 || false
    = 2 
复制代码

10. 位运算符

位运算符是在数字底层（即表示数字的 32 个数位）进行操作的。

位操作符用于在最基本的层次上，即按内存中表示数值的位来操作数值。ECMAScript 中的所有数值都以 IEEE-754 64位格式存储，但位操作符并不直接操作64位的值。而是先将 64 位的值转换成 32 位的整数，然后执行操作，最后再将结果转换回 64 位

重温ECMAScript整数

ECMAScript 整数有两种类型，即有符号整数（允许用正数和负数）和无符号整数（只允许用正数）。在 ECMAScript 中，所有整数字面量默认都是有符号整数，这意味着什么呢？

有符号整数使用 31 位表示整数的数值，用第 32 位表示整数的符号，0 表示正数，1 表示负数。数值范围从 -2147483648 到 2147483647。

可以以两种不同的方式存储二进制形式的有符号整数，一种用于存储正数，一种用于存储负数。正数是以真二进制形式存储的，前 31 位中的每一位都表示 2 的幂，从第 1 位（位 0）开始，表示 20，第 2 位（位 1）表示 21。没用到的位用 0 填充，即忽略不计。例如，下图展示的是数 18 的表示法。

18 的二进制版本只用了前5位，它们是这个数字的有效位。把数字转换成二进制字符串，就能看到有效位：

var iNum = 18;
alert(iNum.toString(2));	//输出 "10010"
复制代码

这段代码只输出 "10010"，而不是 18 的 32 位表示。其他的数位并不重要，因为仅使用前 5 位即可确定这个十进制数值。如下图所示：

负数也存储为二进制代码，不过采用的形式是二进制补码。

计算数字二进制补码的步骤有三步：

• 确定该数字的非负版本的二进制表示（例如，要计算 -18的二进制补码，首先要确定 18 的二进制表示）
• 求得二进制反码，即要把 0 替换为 1，把 1 替换为 0
• 在二进制反码上加 1

要根据这 3 个步骤求得-18 的二进制码

• 首先就要求得 18 的二进制码，即：

  0000 0000 0000 0000 0000 0000 0001 0010

• 然后，求其二进制反码，即 0 和 1 互换：

  1111 1111 1111 1111 1111 1111 1110 1101

• 最后，二进制反码加 1：

  1111 1111 1111 1111 1111 1111 1110 1101

  1111 1111 1111 1111 1111 1111 1110 1110

这样，就求得了-18 的二进制表示，即 11111111111111111111111111101110。

在处理有符号整数时，开发者不能访问 31 位。

有趣的是，把负整数转换成二进制字符串后，ECMAScript 并不以二进制补码的形式显示，而是用数字绝对值的标准二进制代码前面加负号的形式输出。例如：

var iNum = -18;
alert(iNum.toString(2));	//输出 "-10010"
复制代码

这段代码输出的是 "-10010"，而非二进制补码，这是为避免访问位 31。

默认情况下，ECMAScript中的所有整数字面量都默认存储为有符号整数,当然也存在无符号整数,但是只有ECMAScript的位运算符才能创建无符号整数。

对于无符号整数来说，第32位不再表示符号，因为无符号整数只能是正数,无符号整数把最后一位作为另一个数位处理。在这种模式中，第32位不表示数字的符号，而是值2³¹。由于这个额外的位，无符号整数的数值范围为0到4294967295。对于小于2147483647的整数来说，无符号整数看来与有符号整数一样，而大于 2147483647 的整数则要使用位 31（在有符号整数中，这一位总是 0）。

把无符号整数转换成字符串后，只返回它们的有效位。

位运算符

如果对非数值应用位操作符，会先使用Number()函数将该值转换为一个数值（自动完成），然后再应用位操作。得到的结果将是一个数值

位运算 NOT

位运算 NOT 由否定号（~）表示，它是ECMAScript中为数不多的与二进制算术有关的运算符之一。

位运算 NOT 是三步的处理过程：

• 把运算数转换成 32 位数字
• 把二进制数转换成它的二进制反码
• 把二进制数转换成浮点数

var iNum1 = 25;		//25 等于 00000000000000000000000000011001
var iNum2 = ~iNum1;	//转换为  11111111111111111111111111100110
alert(iNum2);		//输出 "-26"
复制代码

位运算 NOT 实质上是对数字求负，然后减1，因此25变-26。用下面的方法也可以得到同样的方法：

var iNum1 = 25;
var iNum2 = -iNum1 -1;
alert(iNum2);	//输出 -26
复制代码

位与运算 AND

位与运算 AND 由和号（&）表示，它有两个操作符数，直接对数字的二进制形式进行运算。

按位与操作就是将两个数值的每一位对齐，然后根据下表中的规则，对相同位置上的两个数执行 AND 操作：（相当于&& 都1才1 有0就0）

第一个数字中的数位	第二个数字中的数位	结果
1	1	1
1	0	0
0	1	0
0	0	0

//例如，要对数字 25 和 3 进行 AND 运算，代码如下所示：
var iResult = 25 & 3;
alert(iResult);	//输出 "1"
复制代码

25 和 3 进行 AND 运算的结果是 1。为什么？分析如下：

    25 = 0000 0000 0000 0000 0000 0000 0001 1001
     3 = 0000 0000 0000 0000 0000 0000 0000 0011
    ---------------------------------------------
   AND = 0000 0000 0000 0000 0000 0000 0000 0001

可以看出，在 25 和 3 中，只有一个数位（位0）存放的都是1，因此，其他数位生成的都是 0，所以结果为 1。

位或运算 OR

位或运算 OR 由符号（|）表示，有两个操作数，也是直接对数字的二进制形式进行运算。

在计算每位时，OR 运算符采用下列规则：（相当于或|| 有1就1 都0才0）

第一个数字中的数位	第二个数字中的数位	结果
1	1	1
1	0	1
0	1	1
0	0	0

//仍然使用 AND 运算符所用的例子，对 25 和 3 进行 OR 运算，代码如下：
var iResult = 25 | 3;
alert(iResult);	//输出 "27"
复制代码

25 和 3 进行 OR 运算的结果是 27：

    25 = 0000 0000 0000 0000 0000 0000 0001 1001
     3 = 0000 0000 0000 0000 0000 0000 0000 0011
    --------------------------------------------
    OR = 0000 0000 0000 0000 0000 0000 0001 1011

可以看出，在两个数字中，共有 4 个数位存放的是1，这些数位被传递给结果。二进制代码 11011 等于 27。

位异或运算 XOR

位异或运算 XOR 由符号（^）表示，有两个操作数，也是直接对二进制形式进行运算。

真值表如下：（当只有一个数位存放的是 1 时，它才返回 1）

第一个数字中的数位	第二个数字中的数位	结果
1	1	0
1	0	1
0	1	1
0	0	0

//对 25 和 3 进行 XOR 运算，代码如下：
var iResult = 25 ^ 3;
alert(iResult);	//输出 "26"
复制代码

25 和 3 进行 XOR 运算的结果是 26：

     25 = 0000 0000 0000 0000 0000 0000 0001 1001
      3 = 0000 0000 0000 0000 0000 0000 0000 0011
    ---------------------------------------------
    XOR = 0000 0000 0000 0000 0000 0000 0001 1010

可以看出，在两个数字中，共有 4 个数位存放的是 1，这些数位被传递给结果。二进制代码 11010 等于 26。

左移运算

左移运算由两个小于号表示（<<）。它把数字中的所有数位向左移动指定的数量

//例如，把数字 2（等于二进制中的10）左移5位，结果为64（等于二进制中的1000000）：
var iOld = 2;		//等于二进制 10
var iNew = iOld << 5;	//等于二进制 1000000 十进制 64
复制代码

注意：在左移数位时，数字右边多出5个空位。左移运算用0填充这些空位，使结果成为完整的 32 位数字。

注意：左移运算保留数字的符号位。例如，如果把 -2 左移 5 位，得到的是 -64，而不是 64。“符号仍然存储在第32位中吗？”是的，不过这在ECMAScript后台进行，开发者不能直接访问第 32 个数位。即使输出二进制字符串形式的负数，显示的也是负号形式（例如，-2 将显示 -10。）

有符号右移运算

有符号右移运算符由两个大于号表示（>>）。它把32位数字中的所有数位整体右移，同时保留该数的符号位（正号或负号）。有符号右移运算符恰好与左移运算相反。

//例如，把 64 右移 5 位，将变为 2：
var iOld = 64;		//等于二进制 1000000
var iNew = iOld >> 5;	//等于二进制 10 十进制 2
复制代码

同样，移动数位后会造成空位。这次，空位位于数字的左侧，但位于符号位之后。ECMAScript 用符号位的值填充这些空位，创建完整的数字，如下图所示：

无符号右移运算

无符号右移操作符由 3 个大于号（>>>）表示，这个操作符会将数值的所有32位都向右移动。

对正数来说，无符号右移的结果与有符号右移相同。

//仍以前面有符号右移的代码为例，如果将 64 无符号右移 5 位，结果仍然还是 2：
var oldValue = 64; // 等于二进制的 1000000
var newValue = oldValue >>> 5; // 等于二进制的 10 ，即十进制的 2
复制代码

对负数来说,

• 无符号右移是以0来填充空位，而不是像有符号右移那样以符号位的值来填充空位
• 无符号右移操作符会把负数的二进制码当成正数的二进制码
• 由于负数以其绝对值的二进制补码形式表示，因此就会导致无符号右移后的结果非常之大

var oldValue = -64; //  等于二进制的 11111111111111111111111111000000
var newValue = oldValue >>> 5; // 等于十进制的 134217726
// 是因为-64 的二进制码为11111111111111111111111111000000，而且无符号右移操作会这个二进制码当成正数的二进制码，换算成十进制就是 4294967232。如果把这个值右移 5 位，结果就变成了00000111111111111111111111111110，即十进制的 134217726。
复制代码

转载于:https://juejin.im/post/5af501e951882567336ac6b9