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变成为numbers2++; // 值变成NaN 数据类型由string变成为numberb++; // 值变成数值1 数据类型由Boolean变成为numberf--; // 值变成 0.10000000000000009（由于浮点舍入错误所致） 数据类型number不改变o--; // 值变成数值-2 数据类型由object变成为numberu++; // 值变成NaN 数据类型由undefined变成为numbern++; // 值变成1 数据类型由null变成为number复制代码 一元加法、减法操作符 + -
一元加法、减法操作符作用
- 基本加减法算术运算
- 用于转换数据类型
一元加法操作符 +
- 用于一元加法运算
- 放在数值前面，对数值不会产生任何影响
var iNum = 20;iNum = +iNum;alert(iNum); //输出 "20"复制代码
- 用于转换数据类型
- 在对非数值应用一元加操作符时，该操作符会像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变成为numbers2 = +s2; // 值变成数值 1.1 数据类型由string变成为numbers3 = +s3; // 值变成 NaN 数据类型由string变成为numberb = +b; // 值变成数值 0 数据类型由Boolean变成为numberf = +f; // 值未变，仍然是 1.1 数据类型numbero = +o; // 值变成数值-1 数据类型由object变成为numberu = +u; // 值变成NaN 数据类型由undefined变成为numbern = +n; // 值变成0 数据类型由null变成为number复制代码 一元减操作符 -
- 用于一元减法运算
- 一元减操作符应用于数值时，该值会变成负数
var iNum = 20;iNum = -iNum;alert(iNum); //输出 "-20"复制代码
- 用于转换数据类型
- 应用于非数值时，该操作符会像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; // 值变成了数值-1s2 = -s2; // 值变成了数值-1.1s3 = -s3; // 值变成了 NaNb = -b; // 值变成了数值 0f = -f; // 变成了-1.1o = -o; // 值变成了数值 1u = -u; // 值变成NaN 数据类型由undefined变成为numbern = -n; // 值变成0 数据类型由null变成为number复制代码 2. 加性操作符 + -
加法
- 如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：（ 两个操作符都是数值，+ 相当于加法算术运算符 ）
- 如果有一个操作数是 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复制代码
-
如果参与计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。(如果操作数里有字符串先以下面的规则为准则)
-
如果有一个操作数是字符串，根据下列规则返回结果：
（注： 此时的 + 成为 字符串连接操作符）
- 如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来
- 如果只有一个操作数是字符串，则将另一个非字符串的操作数转换为字符串，然后再将两个字符串拼接起来。
- 如果只有一个字符串，且另一个操作数是对象、数值、布尔值，则调用他们的toString()方法取得相应的字符串值，然后再应用前面的字符串的规则。
- 如果只有一个字符串，且另一个操作数是undefined、null，则分别调用String()函数将他们转化为 "undefined"和"null"，然后再应用前面的字符串的规则。
console.log(1+1) //2console.log(1+NaN) //NaNconsole.log(1+true) //2console.log(false+true) //1console.log("str"+"56") //str56console.log("str"+56) //str56console.log("str"+{a:1}) //str[object Object]console.log("str"+null) //strnullconsole.log("str"+undefined)//strundefined复制代码 减法
- 如果两个操作符都是数值，执行常规的减法计算，然后根据下列规则返回结果：（ 两个操作符都是数值，- 相当于减法算术运算符 ）
- 如果有一个操作数是 NaN ，则结果是 NaN ；
- 如果是 Infinity 减 Infinity ，则结果是 NaN；
- 如果是 -Infinity 减 -Infinity ，则结果是 NaN ；
- 如果是 Infinity 减 -Infinity ，则结果是 Infinity ；
- 如果是 -Infinity 减 Infinity ，则结果是 -Infinity ；
- 如果是 +0 减 +0，则结果是 +0；
- 如果是 -0 减 -0，则结果是 +0；
- 如果是 +0 减 -0，则结果是 -0。
- 如果参与计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。(如果有下面特殊情况，以下面的规则为准则)
- 如果有一个操作数是字符串、布尔值、 null 或 undefined ，则先在后台调用Number() 函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是NaN，则减法的结果就是 NaN ；
- 如果有一个操作数是对象，则调用对象的valueOf()方法以取得表示该对象的数值。如果得到的值是 NaN ，则减法的结果就是NaN。如果对象没有valueOf()方法，则调用其toString()方法并将得到的字符串转换为数值。
var result2 = NaN - 1; // NaNvar result3 = 5 - 3; // 2var result4 = 5 - ""; // 5，因为"" 被转换成了 0var result5 = 5 - "2"; // 3，因为"2"被转换成了 2var result1 = 5 - true; // 4，因为 true 被转换成了 1var result5 = 5 - undefined; // NaN，因为undefined被转换成了NaNvar result6 = 5 - null; // 5，因为 null 被转换成了 0复制代码
注：一元加法操作符和加性操作符加法的区别：
一元加法操作符：
- 是一元加法运算 如 n = +n
- 改变操作数的数据类型
加性操作符的加法：
- 是两元（多元）加法运算 如 n = a + b
- 不改变操作数的数据类型
3. 乘性操作符 * / %
乘法
乘法操作符由一个星号（ * ）表示，用于计算两个数值的乘积。
乘法操作符遵循下列特殊的规则：
- 如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了ECMAScript数值的表示范围，则返回 Infinity 或 -Infinity ；
- 如果有一个操作数是 NaN ，则结果是 NaN ；
- 如果是 Infinity 与 0 相乘，则结果是 NaN ；
- 如果是 Infinity 与非0数值相乘，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
- 如果是 Infinity 与 Infinity 相乘，则结果是 Infinity ；
- 如果有一个操作数不是数值，则非数值调用Number()将其转换为数值，然后再应用上面的规则。
console.log(12 * 56) //672console.log(12 * "") //0console.log(12 * "str") //NaNconsole.log(12 * true) //12console.log(12 * null) //0console.log(12 * undefined) //NaNconsole.log(12 * {a:1}) //NaNconsole.log(12 * NaN) //NaN复制代码 除法
除法操作符由一个斜线符号（/）表示，执行第二个操作数除第一个操作数的计算
除法操作符遵循下列特殊的规则：
- 如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果商超过了ECMAScript数值的表示范围，则返回 Infinity 或 -Infinity ；
- 如果有一个操作数是 NaN ，则结果是 NaN ；
- 如果是 Infinity 被 Infinity 除，则结果是 NaN ；
- 如果是零被零除，则结果是 NaN ；
- 如果是非零的有限数被零除，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
- 如果是 Infinity 被任何非零数值除，则结果是Infinity或-Infinity，取决于有符号操作数的符号；
- 如果有一个操作数不是数值，则非数值调用Number()将其转换为数值，然后再应用上面的规则。
console.log(12 / 3) //4console.log(12 / "") //Infinityconsole.log(12 / "str") //NaNconsole.log(12 / true) //12console.log(12 / null) //Infinityconsole.log(12 / undefined) //NaNconsole.log(12 / {a:1}) //NaNconsole.log(12 / NaN) //NaN复制代码 求模
求模（余数）操作符由一个百分号（ % ）表示
求模操作符遵循下列特殊的规则：
- 如果操作数都是数值，执行常规的除法计算，返回除得的余数；
- 如果被除数是无穷大值而除数是有限大的数值，则结果是 NaN ；
- 如果被除数是有限大的数值而除数是零，则结果是 NaN ；
- 如果是 Infinity 被 Infinity 除，则结果是 NaN ；
- 如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数；
- 如果被除数是零，则结果是零；
- 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。
4. 布尔操作符
逻辑非（NOT）
逻辑非操作符由一个叹号（！）表示
-
逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。逻辑非操作符一定会返回一个布尔值。
逻辑非操作符遵循下列规则：
- 如果操作数是一个对象，返回 false ；
- 如果操作数是一个空字符串，返回 true ；
- 如果操作数是一个非空字符串，返回 false ；
- 如果操作数是数值 0，返回 true ；
- 如果操作数是任意非 0 数值（包括 Infinity ），返回 false ；
- 如果操作数是 null ，返回 true ；
- 如果操作数是 NaN ，返回 true ；
- 如果操作数是 undefined ，返回 true 。
alert(!false); // truealert(!"blue"); // falsealert(!0); // truealert(!NaN); // truealert(!""); // truealert(!12345); // false复制代码
-
逻辑非操作符可以用于将一个值转换为与其对应的布尔值。
同时使用两个逻辑非操作符，实际上就会模拟 Boolean()转型函数的行为。其中，第一个逻辑非操作会基于无论什么操作数返回一个布尔值，而第二个逻辑非操作则对该布尔值求反，于是就得到了这个值真正对应的布尔值。alert(!!"blue"); //truealert(!!0); //falsealert(!!NaN); //falsealert(!!""); //falsealert(!!12345); //true复制代码
逻辑与（AND）
逻辑与操作符由两个和号（ && ）表示，有两个操作数
-
操作数都是布尔值，返回一定是布尔值
根据逻辑与&&的真值表第一个操作数 第二个操作数 结果 true true true true false false false true false false false false -
在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值
当逻辑运算两侧不都是布尔值参与时，会将其他数据隐式转换为布尔值。
- 隐式转为false：0，“”, NaN, undefined, null
- 隐式转为true: 非0数字（Infinity），非空字符串
根据逻辑与&&的短路语法（串联电路）：
- 如果第一个操作数是 false ，则无论第二个操作数是什么值，结果都不再可能是 true
- 遇到false 返回 值是false的操作数
4 && "hello" //返回 “hello”复制代码
逻辑或（OR）
逻辑或操作符由两个竖线符号（ || ）表示，有两个操作数
-
操作数都是布尔值，返回一定是布尔值
根据逻辑或||的真值表第一个操作数 第二个操作数 结果 true true true true false true false true true false false false -
在有一个操作数不是布尔值的情况下，逻辑或操作就不一定返回布尔值
当逻辑运算两侧不都是布尔值参与时，会将其他数据隐式转换为布尔值。
- 隐式转为false：0，“”, NaN, undefined, null
- 隐式转为true: 非0数字（Infinity），非空字符串
根据逻辑或||的短路语法（并联电路）：
- 如果第一个操作数的求值结果为true ，就不会对第二个操作数求值
- 遇到true 返回 值是true的操作数
4 || "hello" //返回 4复制代码
-
利用逻辑或的这一行为来避免为变量赋 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; //falsevar result = "Brick" < "alphabet"; //truevar result = "23" < "3"; //truevar result = "23" < 3; //false console.log({a:1} < 3) //false，因为{a:1}被转换成了 NaNconsole.log(true < 3) //truevar 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 //truenull == undefined //true "NaN" == NaN //false true == 2 //false5 == NaN //false undefined == 0 //falseNaN == NaN //false null == 0 //false 在检查相等性不能把 null转换成其他值NaN != NaN //true "5"==5 //truefalse == 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 的表示法。
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位不表示数字的符号，而是值231。由于这个额外的位，无符号整数的数值范围为0到4294967295。对于小于2147483647的整数来说，无符号整数看来与有符号整数一样，而大于 2147483647 的整数则要使用位 31（在有符号整数中，这一位总是 0）。
把无符号整数转换成字符串后，只返回它们的有效位。
位运算符
如果对非数值应用位操作符，会先使用Number()函数将该值转换为一个数值（自动完成），然后再应用位操作。得到的结果将是一个数值
位运算 NOT
位运算 NOT 由否定号（~）表示，它是ECMAScript中为数不多的与二进制算术有关的运算符之一。
位运算 NOT 是三步的处理过程：
- 把运算数转换成 32 位数字
- 把二进制数转换成它的二进制反码
- 把二进制数转换成浮点数
var iNum1 = 25; //25 等于 00000000000000000000000000011001var iNum2 = ~iNum1; //转换为 11111111111111111111111111100110alert(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; //等于二进制 10var iNew = iOld << 5; //等于二进制 1000000 十进制 64复制代码
注意：在左移数位时，数字右边多出5个空位。左移运算用0填充这些空位，使结果成为完整的 32 位数字。
有符号右移运算
有符号右移运算符由两个大于号表示（>>）。它把32位数字中的所有数位整体右移，同时保留该数的符号位（正号或负号）。有符号右移运算符恰好与左移运算相反。
//例如，把 64 右移 5 位，将变为 2：var iOld = 64; //等于二进制 1000000var iNew = iOld >> 5; //等于二进制 10 十进制 2复制代码
同样，移动数位后会造成空位。这次，空位位于数字的左侧，但位于符号位之后。ECMAScript 用符号位的值填充这些空位，创建完整的数字，如下图所示：
无符号右移运算
无符号右移操作符由 3 个大于号（>>>）表示，这个操作符会将数值的所有32位都向右移动。
对正数来说，无符号右移的结果与有符号右移相同。
//仍以前面有符号右移的代码为例，如果将 64 无符号右移 5 位，结果仍然还是 2：var oldValue = 64; // 等于二进制的 1000000var newValue = oldValue >>> 5; // 等于二进制的 10 ，即十进制的 2复制代码
对负数来说,
- 无符号右移是以0来填充空位，而不是像有符号右移那样以符号位的值来填充空位
- 无符号右移操作符会把负数的二进制码当成正数的二进制码
- 由于负数以其绝对值的二进制补码形式表示，因此就会导致无符号右移后的结果非常之大
var oldValue = -64; // 等于二进制的 11111111111111111111111111000000var newValue = oldValue >>> 5; // 等于十进制的 134217726// 是因为-64 的二进制码为11111111111111111111111111000000，而且无符号右移操作会这个二进制码当成正数的二进制码，换算成十进制就是 4294967232。如果把这个值右移 5 位，结果就变成了00000111111111111111111111111110，即十进制的 134217726。复制代码