2017年11月12日--2（ES----运算符）----详细的结构

ECMAScript 运算符

 

一元运算符：
delete
delete 运算符删除对以前定义的对象属性或方法的引用。例如：
var o = new Object;
o.name = "David";
alert(o.name); //输出 "David"
delete o.name;
alert(o.name); //输出 "undefined"

在这个例子中，删除了 name 属性，意味着强制解除对它的引用，将其设置为 undefined（即创建的未初始化的变量的值）。
delete 运算符不能删除开发者未定义的属性和方法。例如，下面的代码将引发错误：
delete o.toString;
即使 toString 是有效的方法名，这行代码也会引发错误，因为 toString() 方法是原始的 ECMAScript 方法，不是开发者定义的。

void
void 运算符对任何值返回 undefined。该运算符通常用于避免输出不应该输出的值，例如，从 HTML 的 <a> 元素调用 JavaScript 函数时。
要正确做到这一点，函数不能返回有效值，否则浏览器将清空页面，只显示函数的结果。例如：

<a href="javascript:window.open('about:blank')">Click me</a>
如果把这行代码放入 HTML 页面，点击其中的链接，即可看到屏幕上显示 "[object]"。TIY
这是因为 window.open() 方法返回了新打开的窗口的引用。然后该对象将被转换成要显示的字符串。
要避免这种效果，可以用 void 运算符调用 window.open() 函数：
<a href="javascript:void(window.open('about:blank'))">Click me</a>
这使 window.open() 调用返回 undefined，它不是有效值，不会显示在浏览器窗口中。
提示：请记住，没有返回值的函数真正返回的都是 undefined。
提示：请记住，没有返回值的函数真正返回的都是 undefined。
提示：请记住，没有返回值的函数真正返回的都是 undefined。

 

前增量/前减量运算符

所谓前增量运算符，就是数值上加 1，形式是在变量前放两个加号（++）：
同样，前减量运算符是从数值上减 1，形式是在变量前放两个减号（--）：

在算术表达式中，前增量和前减量运算符的优先级是相同的，因此要按照从左到右的顺序计算之。例如：
var iNum1 = 2;
var iNum2 = 20;
var iNum3 = --iNum1 + ++iNum2; //等于 "22"
var iNum4 = iNum1 + iNum2; //等于 "22"
在前面的代码中，iNum3 等于 22，因为表达式要计算的是 1 + 21。变量 iNum4 也等于 22，也是 1 + 21。

后增量/后减量运算符

 

下面是一个重点：
与前缀式运算符不同的是，后缀式运算符是在计算过包含它们的表达式后才进行增量或减量运算的。考虑以下的例子：
var iNum = 10;
iNum--;
alert(iNum); //输出 "9"
alert(iNum--); //输出 "9"
alert(iNum); //输出 "8"
与前缀式运算符的例子相似，第二行代码对 iNum 进行减量运算，第三行代码显示结果（"9"）。第四行代码继续显示 iNum 的值，
不过这次是在同一语句中应用减量运算符。由于减量运算发生在计算过表达式之后，所以这条语句显示的数是 "9"。
执行了第五行代码后，alert 函数显示的是 "8"，因为在执行第四行代码之后和执行第五行代码之前，执行了后减量运算。

在算术表达式中，后增量和后减量运算符的优先级是相同的，因此要按照从左到右的顺序计算之。例如：
var iNum1 = 2;
var iNum2 = 20;
var iNum3 = iNum1-- + iNum2++; //等于 "22"
var iNum4 = iNum1 + iNum2; //等于 "22"
在前面的代码中，iNum3 等于 22，因为表达式要计算的是 2 + 20。变量 iNum4 也等于 22，不过它计算的是 1 + 21，
因为增量和减量运算都在给 iNum3 赋值后才发生。

一元加法和一元减法
大多数人都熟悉一元加法和一元减法，它们在 ECMAScript 中的用法与您高中数学中学到的用法相同。
一元加法本质上对数字无任何影响：
尽管一元加法对数字无作用，但对字符串却有有趣的效果，会把字符串转换成数字。
var sNum = "20";
alert(typeof sNum); //输出 "string"
var iNum = +sNum;
alert(typeof iNum); //输出 "number"

 

同理减法发。

 

逻辑运算符

参数类型 结果
Undefined false
Null false
Boolean 结果等于输入的参数（不转换）
Number 如果参数为 +0, -0 或 NaN，则结果为 false；否则为 true。
String 如果参数为空字符串，则结果为 false；否则为 true。
Object true
true true
false false

 

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

 

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

逻辑 AND 运算的运算数可以是任何类型的，不止是 Boolean 值。
如果某个运算数不是原始的 Boolean 型值，逻辑 AND 运算并不一定返回 Boolean 值：
如果一个运算数是对象，另一个是 Boolean 值，返回该对象。
如果两个运算数都是对象，返回第二个对象。
如果某个运算数是 null，返回 null。
如果某个运算数是 NaN，返回 NaN。
如果某个运算数是 undefined，发生错误。

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

运算顺序从左到右；

逻辑 OR 运算符

与逻辑 AND 运算符相似，如果某个运算数不是 Boolean 值，逻辑 OR 运算并不一定返回 Boolean 值：
如果一个运算数是对象，并且该对象左边的运算数值均为 false，则返回该对象。
如果两个运算数都是对象，返回第一个对象。
如果最后一个运算数是 null，并且其他运算数值均为 false，则返回 null。
如果最后一个运算数是 NaN，并且其他运算数值均为 false，则返回 NaN。
如果某个运算数是 undefined，发生错误。
与逻辑 AND 运算符一样，逻辑 OR 运算也是简便运算。对于逻辑 OR 运算符来说，如果第一个运算数值为 true，就不再计算第二个运算数。
例如：

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

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

不过，在处理特殊值时，ECMAScript 中的乘法还有一些特殊行为：
如果结果太大或太小，那么生成的结果是 Infinity 或 -Infinity。
如果某个运算数是 NaN，结果为 NaN。
Infinity 乘以 0，结果为 NaN。
Infinity 乘以 0 以外的任何数字，结果为 Infinity 或 -Infinity。
Infinity 乘以 Infinity，结果为 Infinity。
注释：如果运算数是数字，那么执行常规的乘法运算，即两个正数或两个负数为正数，两个运算数符号不同，结果为负数。

除法运算符
除法运算符由斜杠（/）表示，用第二个运算数除第一个运算数：
var iResult = 88 /11;

与乘法运算符相似，在处理特殊值时，除法运算符也有一些特殊行为：
如果结果太大或太小，那么生成的结果是 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"

减法运算符
减法运算符（-），也是一个常用的运算符

与加法运算符一样，在处理特殊值时，减法运算符也有一些特殊行为：
某个运算数是 NaN，那么结果为 NaN。
Infinity 减 Infinity，结果为 NaN。
-Infinity 减 -Infinity，结果为 NaN。
Infinity 减 -Infinity，结果为 Infinity。
-Infinity 减 Infinity，结果为 -Infinity。
+0 减 +0，结果为 +0。
-0 减 -0，结果为 -0。
+0 减 -0，结果为 +0。
某个运算符不是数字，那么结果为 NaN。
注释：如果运算数都是数字，那么执行常规的减法运算，并返回结果。

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

常规比较方式

每个关系运算符都返回一个布尔值：
var bResult1 = 2 > 1 //true
var bResult2 = 2 < 1 //false
不过，对两个字符串应用关系运算符，它们的行为则不同。许多人认为小于表示“在字母顺序上靠前”，大于表示“在字母顺序上靠后”，但事实并非如此。
对于字符串，第一个字符串中每个字符的代码都与会第二个字符串中对应位置的字符的代码进行数值比较。完成这种比较操作后，返回一个 Boolean 值。
问题在于大写字母的代码都小于小写字母的代码，这意味这着可能会遇到下列情况：
var bResult = "Blue" < "alpha";
alert(bResult); //输出 true
在上面的例子中，字符串 "Blue" 小于 "alpha"，因为字母 B 的字符代码是 66，字母 a 的字符代码是 97。要强制性得到按照真正的字母顺序比较的结果，
必须把两个数转换成相同的大小写形式（全大写或全小写的），然后再进行比较：

比较数字和字符串

另一种棘手的状况发生在比较两个字符串形式的数字时，比如：
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);
根据规则，任何包含 NaN 的关系运算符都要返回 false，因此这段代码也输出 false：

 

ECMAScript 等性运算符

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

执行类型转换的规则如下：
如果一个运算数是 Boolean 值，在检查相等性之前，把它转换成数字值。false 转换成 0，true 为 1。
如果一个运算数是字符串，另一个是数字，在检查相等性之前，要尝试把字符串转换成数字。
如果一个运算数是对象，另一个是字符串，在检查相等性之前，要尝试把对象转换成字符串。
如果一个运算数是对象，另一个是数字，在检查相等性之前，要尝试把对象转换成数字。
在比较时，该运算符还遵守下列规则：
值 null 和 undefined 相等。
在检查相等性时，不能把 null 和 undefined 转换成其他值。
如果某个运算数是 NaN，等号将返回 false，非等号将返回 true。
如果两个运算数都是对象，那么比较的是它们的引用值。如果两个运算数指向同一对象，那么等号返回 true，否则两个运算数不等。
重要提示：即使两个数都是 NaN，等号仍然返回 false，因为根据规则，NaN 不等于 NaN。

全等号和非全等号
等号和非等号的同类运算符是全等号和非全等号。这两个运算符所做的与等号和非等号相同，只是它们在检查相等性前，不执行类型转换。
全等号由三个等号表示（===），只有在无需类型转换运算数就相等的情况下，才返回 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"

 

ECMAScript 条件运算符--------又叫三元表达式；
条件运算符
条件运算符是 ECMAScript 中功能最多的运算符，它的形式与 Java 中的相同。
variable = boolean_expression ? true_value : false_value;
该表达式主要是根据 boolean_expression 的计算结果有条件地为变量赋值。如果 Boolean_expression 为 true，
就把 true_value 赋给变量；如果它是 false，就把 false_value 赋给变量。

 

ECMAScript 赋值运算符

赋值运算符
简单的赋值运算符由等号（=）实现，只是把等号右边的值赋予等号左边的变量。

复合赋值运算是由乘性运算符、加性运算符或位移运算符加等号（=）实现的。
每种主要的算术运算以及其他几个运算都有复合赋值运算符：
乘法/赋值（*=）
除法/赋值（/=）
取模/赋值（%=）
加法/赋值（+=）
减法/赋值（-=）
左移/赋值（<<=）
有符号右移/赋值（>>=）
无符号右移/赋值（>>>=）

 

逗号运算符
用逗号运算符可以在一条语句中执行多个运算。
例如：
var iNum1 = 1, iNum = 2, iNum3 = 3;

转载于:https://www.cnblogs.com/gongwu/p/7821920.html