JavaScript运算符

一元运算符

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

---

delete

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

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

在这个例子中，删除了name属性，意味着强制解除对它的引用，将其设置为undefined（即创建的未初始化的变量值）。
注意：delete只是断开属性和宿主对象的联系，而不会操作属性中的属性。
例如：

var o1 = {name:{x:123}};                     var o2 = o1.name;         delete o1.name ;                           console.log(o1);        //Object{}console.log(o2);        //Object{x:123}

因此，在删除对象的时候，需要遍历属性中的属性，依次删除。
例如：

var o1 = {name:{x:123}};                     var o2 = o1.name;         delete o1.name ;    delete o1.name.x ;                         console.log(o1);        //Object{}console.log(o2);        //Object{}

②delete运算符不能删除开发者未定义的属性和方法以及原始的ECMAScript方法。
例如：

var o1 = {name:{x:123}};                             delete o1.getValue() ;    //程序出错                     

③delete运算符可以删除数组元素。
例如：

var arr=[1,2,3,4];                     console.log(arr);               //[1,2,3,4]  console.log(delete arr[2]);     //true,删除成功  console.log(arr);               //[1,2,underfined×1,4]                    

④delete运算符的返回值。
注意，delete返回值为false时：

• delete删除对象的不可配置属性
  例如：通过变量声明和函数声明创建的全局对象的属性。

  alert(delete Object.prototype);         //falsevar iNumber=1;alert(delete iNumber);                  //falsefunction myFunction(){}alert(delete myFunction);               //false

delete返回值为true时：

• delete表达式删除成功
• delete操作没有任何副作用（例如：删除不存在的属性时）

• delete后不是一个属性访问表达式

  var o = {x:1};alert(delete o.x);          //true，删除成功alert(o.x);                 //undefinedalert(delete o.x);          //true，x已经不存在alert(delete o.toString);   //true，toString是继承来的，相当于不存在alert(delete 1.2);          //true，无意义

void

void 运算符对任何值返回undefined，该运算符用于避免输出不应该输出的值。

<a href="javascript:void(window.open('about:blank'))">Click me</a>

另外：没有返回值的函数真正返回的都是 undefined。

前增量/前减量运算符

前增量运算符，就是数值加1，形式是在变量前放两个加号(++)：

var iNum = 10;++iNum;                 //11，相当于iNum = iNum + 1;

前减量运算符，就是数值减1，形式是在变量前放两个减号(–)：

var iNum = 10;--iNum;                 //9,相当于iNum = iNum - 1;

在使用前缀式运算符时，增量和减量运算符都发生在计算表达式之前。

后增量/后减量运算符

后增量运算符，就是数值加1，形式是在变量后放两个加号(++)：

var iNum = 10;iNum++;                 //该句执行之后，iNum的值才增加到11

后减量运算符，就是数值减1，形式是在变量后放两个减号(–)：

var iNum = 10;iNum--;                 //该句执行之后，iNum的值才减少到9

在使用后缀式运算符时，增量和减量运算符都发生在计算表达式之后。

一元加法和一元减法

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

var iNum = 20;iNum = + iNum;alert(iNum);                //20

一元加法运算符会把字符串转换成数字：

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

一元加法运算符对字符串进行操作时，它计算字符串的方法与parseInt()相似。

与此相似的是，一元减法是对数值求负：

var iNum = 20;iNum = - iNum;alert(iNum);                //-20

一元减法运算符会把字符串转换成数字：

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

一元减法运算符对十六进制和十进制的处理方式与一元加法运算符相似，只是它还会对该值求负。

位运算符

重温整数

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

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

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

正数是以真二进制形式存储的，负数是二进制补码存储的。

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

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

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

位运算 NOT

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

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

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

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

var iNum1 = 25;var iNum2 = -iNum1 -1;alert(iNum2);           //输出 -26

位运算 AND

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

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

即，对应位全部为1，则结果为1，其它情况，结果都为0。
例如：

var iResult = 25 & 3;alert(iResult);             //输出 "1"

位运算 OR

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

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

即，对应位有一个为1，则结果为1，只有对应位全部为0，则结果为0。
例如：

var iResult = 25 & 3;alert(iResult);             //输出 "27"

位运算 XOR

位运算 XOR 由符号（^）表示，也是直接对二进制形式进行运算。真值表如下：

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

即，XOR 不同于 OR，当只有一个数位存放的是 1 时，它才返回 1。
例如：

var iResult = 25 ^ 3;alert(iResult);             //输出 "26"

左移运算

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

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

左移运算保留数字的符号位。
例如：

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

有符号右移运算

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

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

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

无符号右移运算

无符号右移运算符由三个大于号（>>>）表示，它将无符号 32 位数的所有数位整体右移。对于正数，无符号右移运算的结果与有符号右移运算一样。
例如：

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

对于负数，情况就不同了。无符号右移运算用 0 填充所有空位。对于正数，这与有符号右移运算的操作一样，而负数则被作为正数来处理。由于无符号右移运算的结果是一个 32 位的正数，所以负数的无符号右移运算得到的总是一个非常大的数字。例如，如果把 -64 右移 5 位，将得到 134217726。

var iUnsigned64 = -64 >>> 0;        //转换为无符号数alert(iUnsigned64.toString(2));     //11111111111111111111111111000000//此时，可以访问第32位，所以，负数会用补码表示。alert(iUnsigned64 >>> 5);           //134217726

使用无符号右移运算符要小心！！！

逻辑运算符（Boolean 运算符）

Boolean 运算符有三种：NOT、AND 和 OR。
回顾以下，Boolean()操作的转换结果：

转换前数据 转换后 null false undefined false 0以及NaN false 空字符串 false 非0数字 true 非空字符串 true object true

逻辑 NOT 运算符

逻辑 NOT 运算符由感叹号（!）表示，与逻辑 OR 和逻辑 AND 运算符不同的是，逻辑 NOT 运算符返回的一定是 Boolean 值。
逻辑 NOT 运算符的返回值如下：

运算数 返回值 null true undefined true 0以及NaN true 空字符串 true 非0数字 false 非空字符串 false object false

注意：连续使用两次!，可将任意类型转为布尔类型。

var bFalse = false;var sRed = "red";var iZero = 0;var iThreeFourFive = 345;var oObject = new Object;alert("bFalse 的逻辑值是 " + (!bFalse));                 //truealert("sRed 的逻辑值是 " + (!sRed));                     //falsealert("iZero 的逻辑值是 " + (!iZero));                   //truealert("iThreeFourFive 的逻辑值是 " + (!iThreeFourFive)); //falsealert("oObject 的逻辑值是 " + (!oObject));               //falsealert("bFalse 的逻辑值是 " + (!!bFalse));                //falsealert("sRed 的逻辑值是 " + (!!sRed));                    //truealert("iZero 的逻辑值是 " + (!!iZero));                  //falsealert("iThreeFourFive 的逻辑值是 " + (!!iThreeFourFive));//truealert("oObject 的逻辑值是 " + (!!oObject));              //true

逻辑 AND 运算符

在 ECMAScript 中，逻辑 AND 运算符用双和号（&&）表示：
下面的真值表描述了逻辑 AND 运算符的返回值：

运算数(boolean) 运算数(boolean) 返回值 true true true true false false false true false false false false

如果某个运算数不是原始的 Boolean 型值，逻辑 AND 运算并不一定返回 Boolean 值：

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

与 Java 中的逻辑 AND 运算相似，ECMAScript 中的逻辑 AND 运算也是简便运算，即如果第一个运算数决定了结果，就不再计算第二个运算数。

var bTrue = true;var bResult = (bTrue && bUnknown);  //发生错误alert(bResult);                     //这一行不会执行

var bFalse = false;var bResult = (bFalse && bUnknown);alert(bResult);                     //输出 "false"

逻辑 OR 运算符

ECMAScript 中的逻辑 OR 运算符与 Java 中的相同，都由双竖线（||）表示：
下面的真值表描述了逻辑 OR 运算符的返回值：

运算数(boolean) 运算数(boolean) 返回值 true true true true false true false true true false false false

如果某个运算数不是原始的 Boolean 型值，逻辑 OR 运算并不一定返回 Boolean 值：

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

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

var bTrue = true;var bResult = (bTrue || bUnknown);alert(bResult);                         //输出 "true"

var bFalse = false;var bResult = (bFalse || bUnknown);     //发生错误alert(bResult);                         //不会执行这一行

乘性运算符

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

乘法运算符

乘法运算符由星号（*）表示，用于两数相乘。
不过，在处理特殊值时，ECMAScript 中的乘法还有一些特殊行为：

• 如果结果太大或太小，那么生成的结果是 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。

取模运算符

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

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

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

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

加性运算符

在多数程序设计语言中，加性运算符（即加号或减号）通常是最简单的数学运算符。
在 ECMAScript 中，加性运算符有大量的特殊行为。

加法运算符

加法运算符由加号（+）表示。
与乘性运算符一样，在处理特殊值时，ECMAScript 中的加法也有一些特殊行为：

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

不过，如果某个运算数是字符串，那么采用下列规则：

• 如果两个运算数都是字符串，把第二个字符串连接到第一个上。
• 如果只有一个运算数是字符串，把另一个运算数转换成字符串，结果是两个字符串连接成的字符串。

例如：

var result = 5 + 5;             //两个数字alert(result);                  //输出 "10"var result2 = 5 + "5";          //一个数字和一个字符串alert(result);                  //输出 "55"var result3 = 5 + +"1" + "5";   //输出 "65"

注意：+”1”是一元加法云算法，将字符串转换为数字，所以是先数字相加，结果转化为字符串，最后字符串连接。

减法运算符

减法运算符（-），也是一个常用的运算符。
与加法运算符一样，在处理特殊值时，减法运算符也有一些特殊行为：

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

关系运算符

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

常规比较方式

关系运算符小于、大于、小于等于和大于等于执行的是两个数的比较运算，比较方式与算术比较运算相同。

例如：

alert(2 > 1);           //truealert(2 < 1);           //false

不过，对两个字符串应用关系运算符，它们的行为则不同，比较的是字母代码的大小，要区分字母的大小写。

例如：

alert("Blue" < "alpha");                                //输出 truealert("Blue".toLowerCase() < "alpha".toLowerCase());    //输出 false

比较数字和字符串

当比较两个字符串形式的数字时，也是按照其字符代码的大小进行对比。

例如:

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

不过，当某个运算数是数字时，将会将字符串转化为数字,按照数字顺序进行对比。

例如：

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

但是，如果字符串不能转化为数字时，则返回NaN，并且，任何包含NaN的关系运算符都要返回false。

例如：

alert("a" >= 3);            //输出"false"alert("a" < 3);             //输出"false"

等性运算符

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

等号和非等号

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

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

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

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

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

全等号和非全等号

等号和非等号的同类运算符是全等号和非全等号。这两个运算符所做的与等号和非等号相同，只是它们在检查相等性前，不执行类型转换。

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

var sNum = "66";var iNum = 66;alert(sNum == iNum);    //输出 "true"alert(sNum === iNum);   //输出 "false"

非全等号由感叹号加两个等号（!==）表示，只有在无需类型转换运算数不相等的情况下，才返回 true。
例如：

var sNum = "66";var iNum = 66;alert(sNum != iNum);    //输出 "false"alert(sNum !== iNum);   //输出 "true"

注意：

null == undefined 返回值true
null === undefined 返回值false

条件运算符

条件运算符

条件运算符是 ECMAScript 中功能最多的运算符，它的形式与 Java 中的相同。
条件表达式的写法：Boolean_expression？true_value：false_value
相当于简洁的if……else

例如：求iNum1和iNum2之间的最大值。

var iMax = (iNum1 > iNum2) ? iNum1 : iNum2;

赋值运算符

赋值运算符

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

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

下面两段代码等价：

var iNum = 10;iNum = iNum + 10；

var iNum = 10;iNum += 10；

逗号运算符

逗号运算符

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

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

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

本文章主要参考并总结W3School以及W3Cschool
W3School