一、ECMAScript 一元运算符

一元运算符只有一个参数，即要操作的对象或值。它们是 ECMAScript 中最简单的运算符。

1、delete

delete 运算符删除对以前定义的对象属性或方法的引用。

var o = new Object;
o.name = "David";
alert(o.name);  //输出 "David"
delete o.name;
alert(o.name);  //输出 "undefined"

delete 运算符不能删除开发者未定义的属性和方法。例如，下面的代码将引发错误：

delete o.toString;

因为 toString() 方法是原始的 ECMAScript 方法，不是开发者定义的。

2、void

void 运算符对任何值返回 undefined。

提示：请记住，没有返回值的函数真正返回的都是 undefined。

3、前增量（++num）/前减量（--num）运算符

直接从 C（和 Java）借用的两个运算符是前增量运算符和前减量运算符。
所谓前增量运算符，就是数值上加 1，形式是在变量前放两个加号（++）：

    ++iNum;     //等价于 iNum = iNum + 1；
    --iNum;     //等价于 iNum = iNum - 1；

• 注意增量和减量运算符都发生在计算表达式之前。先自增（减）再计算
• 两者优先级相同，按照从左到右的计算。

4、后增量/后减量运算符

还有两个直接从 C（和 Java）借用的运算符，即后增量运算符和后减量运算符。
后增量运算符也是给数值上加 1，形式是在变量后放两个加号（++）：

    iNum++;     //等价于 iNum = iNum + 1；
    iNum--;     //等价于 iNum = iNum - 1；

• 区别：与前缀式运算符不同的是，后缀式运算符是在计算过包含它们的表达式后才进行增量或减量运算的。先计算再自增（减）。

• 两者优先级相同。

5、一元加法和一元减法

一元加法本质上对数字无任何影响：

    var iNum = 20;
    iNum = +iNum;
    alert(iNum);    //输出 "20"

注意：尽管一元加法对数字无作用，但对字符串却有有趣的效果，会把字符串转换成数字。

var sNum = "20";
alert(typeof sNum); //输出 "string"
var iNum = +sNum;
alert(typeof iNum); //输出 "number"

当一元加法运算符对字符串进行操作时，它计算字符串的方式与 parseInt() 相似，主要的不同是只有对以 "0x" 开头的字符串（表示十六进制数字），一元运算符才能把它转换成十进制的值。因此，用一元加法转换 "010"，得到的总是 10，而 "0xB" 将被转换成 11。

一元减法就是对数值求负（例如把 20 转换成 -20）
与一元加法运算符相似，一元减法运算符也会把字符串转换成近似的数字，此外还会对该值求负。

var sNum = "20";
alert(typeof sNum); //输出 "string"
var iNum = -sNum;
alert(iNum);        //输出 "-20"
alert(typeof iNum); //输出 "number"

二、ECMAScript 位运算符

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

1、重温整数

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

有符号整数使用 31 位表示整数的数值，用第 32 位表示整数的符号，0 表示正数，1 表示负数。

• 有符号整数数值范围从 -2147483648 到 2147483647。
• 无符号整数的数值范围为 0 到 4294967295。

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

负数也存储为二进制代码，不过采用的形式是二进制补码。计算负数二进制补码的步骤有三步：

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

要确定 -18 的二进制表示，首先必须得到 18 的二进制表示，如下所示：

0000 0000 0000 0000 0000 0000 0001 0010

接下来，计算二进制反码，如下所示：

1111 1111 1111 1111 1111 1111 1110 1101

最后，在二进制反码上加 1，如下所示：

1111 1111 1111 1111 1111 1111 1110 1101
                                      1
---------------------------------------
1111 1111 1111 1111 1111 1111 1110 1110

因此，-18 的二进制表示即 1111 1111 1111 1111 1111 1111 1110 1110。记住，在处理有符号整数时，开发者不能访问 31 位。
有趣的是，把负整数转换成二进制字符串后，ECMAScript 并不以二进制补码的形式显示，而是用数字绝对值的标准二进制代码前面加负号的形式输出。例如：

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

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

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

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

注意：所有整数字面量都默认存储为有符号整数。只有 ECMAScript 的位运算符才能创建无符号整数。

2、位运算 NOT

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

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

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

位运算 NOT 实质上是对数字求负，然后减 1。

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

3、位运算 AND

位运算 AND 由和号（&）表示，直接对数字的二进制形式进行运算。它把每个数字中的数位对齐，然后用下面的规则对同一位置上的两个数位进行 AND 运算：同真为真，一假为假。

例如，要对数字 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

4、位运算 OR

位运算 OR 由符号（|）表示，也是直接对数字的二进制形式进行运算。在计算每位时，OR 运算符采用下列规则：一真为真，同假为假。

5、位运算 XOR

位运算 XOR 由符号（^）表示，当然，也是直接对二进制形式进行运算。XOR 不同于 OR，当只有一个数位存放的是 1 时，它才返回 1。

对 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

6、左移运算<<

左移运算由两个小于号表示（<<）。它把数字中的所有数位向左移动指定的数量。例如，把数字 2（等于二进制中的 10）左移 5 位，结果为 64（等于二进制中的 1000000）：

var iOld = 2;       //等于二进制 10
var iNew = iOld << 5;   //等于二进制 1000000 十进制 64

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

左移运算

注意：左移运算保留数字的符号位。

7、有符号右移运算

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

8、无符号右移运算

无符号右移运算符由三个大于号（>>>）表示，它将无符号 32 位数的所有数位整体右移。对于正数，无符号右移运算的结果与有符号右移运算一样。
用有符号右移运算中的例子，把 64 右移 5 位，将变为 2：

var iOld = 64;      //等于二进制 1000000
var iNew = iOld >>> 5;  //等于二进制 10 十进制 2

对于负数，情况就不同了。

无符号右移运算用 0 填充所有空位。对于正数，这与有符号右移运算的操作一样，而负数则被作为正数来处理。

由于无符号右移运算的结果是一个 32 位的正数，所以负数的无符号右移运算得到的总是一个非常大的数字。例如，如果把 -64 右移 5 位，将得到 134217726。

三、ECMAScript Boolean 运算符

Boolean 运算符有三种：NOT、AND 和 OR。

• ToBoolean 操作
  在学习各种逻辑运算符之前，让我们先了解一下 ECMAScript-262 v5 规范中描述的 ToBoolean 操作。
  抽象操作 ToBoolean 将其参数按照下表中的规则转换为逻辑值：
  
  ToBoolean 操作

1、逻辑 NOT 运算符

在 ECMAScript 中，逻辑 NOT 运算符与 C 和 Java 中的逻辑 NOT 运算符相同，都由感叹号（!）表示。
与逻辑 OR 和逻辑 AND 运算符不同的是，逻辑 NOT 运算符返回的一定是 Boolean 值。

逻辑 NOT 运算符的行为如下：

• 如果运算数是对象，返回 false
• 如果运算数是数字 0，返回 true
• 如果运算数是 0 以外的任何数字，返回 false
• 如果运算数是 null，返回 true
• 如果运算数是 NaN，返回 true
• 如果运算数是 undefined，发生错误

判断 ECMAScript 变量的 Boolean 值时，也可以使用逻辑 NOT 运算符。这样做需要在一行代码中使用两个 NOT 运算符。无论运算数是什么类型，第一个 NOT 运算符返回 Boolean 值。第二个 NOT 将对该 Boolean 值求负，从而给出变量真正的 Boolean 值。

var bFalse = false;
var sRed = "red";
var iZero = 0;
var iThreeFourFive = 345;
var oObject = new Object;

document.write("bFalse 的逻辑值是 " + (!!bFalse));
document.write("sRed 的逻辑值是 " + (!!sRed));
document.write("iZero 的逻辑值是 " + (!!iZero));
document.write("iThreeFourFive 的逻辑值是 " + (!!iThreeFourFive));
document.write("oObject 的逻辑值是 " + (!!oObject));

结果：

bFalse 的逻辑值是 false
sRed 的逻辑值是 true
iZero 的逻辑值是 false
iThreeFourFive 的逻辑值是 true
oObject 的逻辑值是 true 

2、逻辑 AND 运算符

在 ECMAScript 中，逻辑 AND 运算符用双和号（&&）表示：

逻辑 AND 运算的运算数可以是任何类型的，不止是 Boolean 值。
如果某个运算数不是原始的 Boolean 型值，逻辑 AND 运算并不一定返回 Boolean 值：

• 如果一个运算数是对象，另一个是 Boolean 值，返回该对象。
• 如果两个运算数都是对象，返回第二个对象。
• 如果某个运算数是 null，返回 null。
• 如果某个运算数是 NaN，返回 NaN。
• 如果某个运算数是 undefined，发生错误。

与 Java 中的逻辑 AND 运算相似，ECMAScript 中的逻辑 AND 运算也是简便运算，即如果第一个运算数决定了结果，就不再计算第二个运算数。对于逻辑 AND 运算来说，如果第一个运算数是 false，那么无论第二个运算数的值是什么，结果都不可能等于 true。

3、逻辑 OR 运算符

ECMAScript 中的逻辑 OR 运算符与 Java 中的相同，都由双竖线（||）表示：

与逻辑 AND 运算符相似，如果某个运算数不是 Boolean 值，逻辑 OR 运算并不一定返回 Boolean 值：

• 如果一个运算数是对象，并且该对象左边的运算数值均为 false，则返回该对象。
• 如果两个运算数都是对象，返回第一个对象。
• 如果最后一个运算数是 null，并且其他运算数值均为 false，则返回 null。
• 如果最后一个运算数是 NaN，并且其他运算数值均为 false，则返回 NaN。
• 如果某个运算数是 undefined，发生错误。

与逻辑 AND 运算符一样，逻辑 OR 运算也是简便运算。对于逻辑 OR 运算符来说，如果第一个运算数值为 true，就不再计算第二个运算数。

四、ECMAScript 乘性运算符

ECMAScript 的乘性运算符与 Java、C、Perl 等于语言中的同类运算符的运算方式相似。需要注意的是，乘性运算符还具有一些自动转换功能。

1、乘法运算符

乘法运算符由星号（*）表示，用于两数相乘。

不过，在处理特殊值时，ECMAScript 中的乘法还有一些特殊行为：
-如果结果太大或太小，那么生成的结果是 Infinity 或 -Infinity。

• 如果某个运算数是 NaN，结果为 NaN。
• Infinity 乘以 0，结果为 NaN。
• Infinity 乘以 0 以外的任何数字，结果为 Infinity 或 -Infinity。
• Infinity 乘以 Infinity，结果为 Infinity。

注释：如果运算数是数字，那么执行常规的乘法运算，即两个正数或两个负数为正数，两个运算数符号不同，结果为负数。

2、除法运算符

除法运算符由斜杠（/）表示，用第二个运算数除第一个运算数。

与乘法运算符相似，在处理特殊值时，除法运算符也有一些特殊行为：

• 如果结果太大或太小，那么生成的结果是 Infinity 或 -Infinity。
• 如果某个运算数是 NaN，结果为 NaN。
• Infinity 被 Infinity 除，结果为 NaN。
• Infinity 被任何数字除，结果为 Infinity。
• 0 除一个任何非无穷大的数字，结果为 NaN。
• Infinity 被 0 以外的任何数字除，结果为 Infinity 或 -Infinity。

3、取模运算符

除法（余数）运算符由百分号（%）表示，使用方法如下：

    var iResult = 26%5; //等于 1

与其他乘性运算符相似，对于特殊值，取模运算符也有特殊的行为：

• 如果被除数是 Infinity，或除数是 0，结果为 NaN。
• Infinity 被 Infinity 除，结果为 NaN。
• 如果除数是无穷大的数，结果为被除数。
• 如果被除数为 0，结果为 0。

注释：如果运算数是数字，那么执行常规的算术除法运算，返回除法运算得到的余数。

五、ECMAScript 加性运算符

1、加法运算符

与乘性运算符一样，在处理特殊值时，ECMAScript 中的加法也有一些特殊行为：

• 某个运算数是 NaN，那么结果为 NaN。
• -Infinity 加 -Infinity，结果为 -Infinity。
• Infinity 加 -Infinity，结果为 NaN。
• +0 加 +0，结果为 +0。
• -0 加 +0，结果为 +0。
• -0 加 -0，结果为 -0。

不过，如果某个运算数是字符串，那么采用下列规则：
如果两个运算数都是字符串，把第二个字符串连接到第一个上。
如果只有一个运算数是字符串，把另一个运算数转换成字符串，结果是两个字符串连接成的字符串。

2、减法运算符

与加法运算符一样，在处理特殊值时，减法运算符也有一些特殊行为：

• 某个运算数是 NaN，那么结果为 NaN。
• Infinity 减 Infinity，结果为 NaN。
• -Infinity 减 -Infinity，结果为 NaN。
• Infinity 减 -Infinity，结果为 Infinity。
• -Infinity 减 Infinity，结果为 -Infinity。
• +0 减 +0，结果为 +0。
• -0 减 -0，结果为 -0。
• +0 减 -0，结果为 +0。
• 某个运算符不是数字，那么结果为 NaN。

六、ECMAScript 关系运算符

关系运算符执行的是比较运算。每个关系运算符都返回一个布尔值。

1、常规比较方式

关系运算符小于、大于、小于等于和大于等于执行的是两个数的比较运算，比较方式与算术比较运算相同。最后都返回一个布尔值。

对于字符串，第一个字符串中每个字符的代码都与会第二个字符串中对应位置的字符的代码进行数值比较。完成这种比较操作后，返回一个 Boolean 值。问题在于大写字母的代码都小于小写字母的代码，这意味这着可能会遇到下列情况：

var bResult = "Blue" < "alpha";
alert(bResult); //输出 true

在上面的例子中，字符串 "Blue" 小于 "alpha"，因为字母 B 的字符代码是 66，字母 a 的字符代码是 97。要强制性得到按照真正的字母顺序比较的结果，必须把两个数转换成相同的大小写形式（全大写或全小写的），然后再进行比较：

var bResult = "Blue".toLowerCase() < "alpha".toLowerCase();
alert(bResult); //输出 false

2、比较数字和字符串

另一种棘手的状况发生在比较两个字符串形式的数字时，比如：

var bResult = "25" < "3";
alert(bResult); //输出 "true"

上面这段代码比较的是字符串 "25" 和 "3"。两个运算数都是字符串，所以比较的是它们的字符代码（"2" 的字符代码是 50，"3" 的字符代码是 51）。

不过，如果把某个运算数该为数字，那么结果就有趣了：

var bResult = "25" < 3;
alert(bResult); //输出 "false"

这里，字符串 "25" 将被转换成数字 25，然后与数字 3 进行比较，结果不出所料。

无论何时比较一个数字和一个字符串，ECMAScript 都会把字符串转换成数字，然后按照数字顺序比较它们。

不过，如果字符串不能转换成数字又该如何呢？考虑下面的例子：

var bResult = "a" < 3;
alert(bResult);

你能预料到这段代码输出什么吗？字母 "a" 不能转换成有意义的数字。不过，如果对它调用 parseInt() 方法，返回的是 NaN。根据规则，任何包含 NaN 的关系运算符都要返回 false，因此这段代码也输出 false：

var bResult = "a" >= 3;
alert(bResult);   //false

通常，如果小于运算的两个值返回 false，那么大于等于运算必须返回 true，不过如果某个数字是 NaN，情况则非如此。

七、ECMAScript 等性运算符

ECMAScript 提供了两套等性运算符：等号和非等号用于处理原始值，全等号和非全等号用于处理对象。

1、等号和非等号

在 ECMAScript 中，等号由双等号（==）表示，当且仅当两个运算数相等时，它返回 true。非等号由感叹号加等号（!=）表示，当且仅当两个运算数不相等时，它返回 true。为确定两个运算数是否相等，这两个运算符都会进行类型转换。

执行类型转换的规则如下：

• 如果一个运算数是 Boolean 值，在检查相等性之前，把它转换成数字值。false 转换成 0，true 为 1。
• 如果一个运算数是字符串，另一个是数字，在检查相等性之前，要尝试把字符串转换成数字。
• 如果一个运算数是对象，另一个是字符串，在检查相等性之前，要尝试把对象转换成字符串。
• 如果一个运算数是对象，另一个是数字，在检查相等性之前，要尝试把对象转换成数字。

在比较时，该运算符还遵守下列规则：

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

重要提示：即使两个数都是 NaN，等号仍然返回 false，因为根据规则，NaN 不等于 NaN。

等号和非等号

2、全等号和非全等号

全等号由三个等号表示（===），只有在无需类型转换运算数就相等的情况下，才返回 true。全等必须值和类型都相等才返回true。

八、ECMAScript 条件运算符

variable = boolean_expression ? true_value : false_value;

如果 Boolean_expression 为 true，就把 true_value 赋给变量；如果它是 false，就把 false_value 赋给变量。

九、ECMAScript 赋值运算符

赋值运算符：

• 简单的赋值运算符由等号（=）实现，只是把等号右边的值赋予等号左边的变量。
• 复合赋值运算是由乘性运算符、加性运算符或位移运算符加等号（=）实现的

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

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

十、ECMAScript 逗号运算符

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

例如：

var iNum1 = 1, iNum = 2, iNum3 = 3;

逗号运算符常用变量声明中。

本文摘自W3shcool教程