这篇文章需要文法复核。如何帮忙。

这篇翻译不完整。请帮忙从英语翻译这篇文章

本章描述了 JavaScript 的表达式和运算符,包括了赋值,比较,算数,按位,逻辑,字符串,三元等等。

一个完整详细的运算符列表和表达式可以参见 reference.

运算符 Operators

JavaScript 拥有如下类型的运算符。本节描述了运算符和运算符的优先级。

JavaScript 拥有二元(binary)和一元(unary)运算符, 和一个特殊的三元(ternary)运算符(条件运算符)。一个二元运算符需要两个操作数(operand),分别在运算符的前面和后面:

操作数1   运算符   操作数2
operand1 operator operand2

例如, 3+4x*y.

一个一元运算符需要一个在运算符(operator)前面或后面的操作数(operand):

运算符    操作数
operator operand

操作数   运算符
operand operator

例如, x++++x.

赋值运算符(Assignment operators)

一个 赋值运算符(assignment operator) 赋一个基于它右边操作数值的值给它左边的操作数。最简单的赋值运算符是等于(=),将右边的操作数值赋给左边的操作数。那么 x = y 就是将 y 的值赋给 x。

在下面的表格中列出了有一些为速记操作的复合赋值运算符:

复合赋值运算符
名字 速记 等同于
赋值 Assignment x = y x = y
加法赋值 Addition assignment x += y x = x + y
减法赋值 Subtraction assignment x -= y x = x - y
乘法赋值 Multiplication assignment x *= y x = x * y
除法赋值 Division assignment x /= y x = x / y
求余赋值 Remainder assignment x %= y x = x % y
求幂赋值 Exponentiation assignment x **= y x = x ** y
左移位赋值 Left shift assignment x <<= y x = x << y
右移位赋值 Right shift assignment x >>= y x = x >> y
无符号右移位赋值 Unsigned right shift assignment x >>>= y x = x >>> y
按位与赋值 Bitwise AND assignment x &= y x = x & y
按位异或赋值 Bitwise XOR assignment x ^= y x = x ^ y
按位或赋值 Bitwise OR assignment x |= y x = x | y

解构 Destructuring

对于一些更复杂的赋值, 这个 解构赋值 destructuring assignment 语法是一个能从数组或对象对应的数组结构或对象字面量里提取数据的 Javascript 表达式。

var foo = ["one", "two", "three"];

// 不使用解构
var one   = foo[0];
var two   = foo[1];
var three = foo[2];

// 使用解构
var [one, two, three] = foo;

比较运算符(Comparison operators)

一个 比较运算符 comparison operator 比较它的操作数并返回一个基于表达式是否为真的逻辑值。操作数可以是数字,字符串,逻辑,对象值。字符串比较是基于标准的字典顺序,使用Unicode值。在多数情况下,如果两个操作数不是相同的类型, JavaScript 会尝试转换它们为恰当的类型来比较。这种行为通常发生在数字作为操作数的比较。类型转换的例外是使用 === 和 !== 操作符,它们会执行严格的平等和非平等比较。这些运算符不会在检查相等之前转换操作数的类型。下面的表格描述了该示例代码中的各比较运算符

var var1 = 3;
var var2 = 4;
比较运算符 Comparison operators
运算符 描述 返回true的示例
等于 Equal (==)

如果两边操作数相等时返回true。

3 == var1

"3" == var1

3 == '3'
不等于 Not equal (!=) 如果两边操作数不相等时返回true var1 != 4
var2 != "3"
全等 Strict equal (===) 两边操作数相等且类型相同时返回true。 参见 Object.is and sameness in JS. 3 === var1
不全等 Strict not equal (!==) 两边操作数不相等或类型不同时返回true。 var1 !== "3"
3 !== '3'
大于 Greater than (>) 左边的操作数大于右边的操作数返回true var2 > var1
"12" > 2
大于等于 Greater than or equal (>=) 左边的操作数大于或等于右边的操作数返回true var2 >= var1
var1 >= 3
小于 Less than (<) 左边的操作数小于右边的操作数返回true var1 < var2
"2" < 12
小于等于 Less than or equal (<=) 左边的操作数小于或等于右边的操作数返回true var1 <= var2
var2 <= 5

Note: (=>) is not an operator, but the notation for Arrow functions.

算术运算符(Arithmetic operators)

算术运算符使用数值(字面量或者变量)作为操作数并返回一个数值.标准的算术运算符就是加减乘除(+ - * /).当操作数是浮点数时,这些运算符表现得跟它们在大多数编程语言中一样(特殊要注意的是,除零会产生Infinity(译者注:大多数编程语言除零会抛出异常))例如:

1 / 2;  // 0.5
1 / 2 == 1.0 / 2.0; // true 

另外,JavaScript还提供了下表中的算术运算符.

表 3.3 算术运算符
Operator Description Example
%
(求余)
二元运算符. 返回相除之后的余数. 13 % 5 返回 3.(译者注:原文的例子是12%5得2,这个例子实在是不好,12与5求余求模都得2)
++
(自增)
一元运算符. 将操作数的值加一. 如果放在操作数前面 (++x), 则返回加一后的值; 如果放在操作数后面 (x++), 则返回操作数原值,然后再将操作数加一.

var x=3;

console.log(++x); //4

console.log(x); //4

var y=3;

console.log(y++); //3

console.log(y); //4

--
(自减)
一元运算符. 将操作数的值减一. 前后缀两种用法的返回值类似自增运算符.

var x=3; console.log(--x); //输入2,x=2

var y=3;console.log(y--);//输出3,x=2;

-
(一元负值符)
一元运算符,返回操作数的负值.

var x=3; console.log(-x); //输入-3

+

 

一元运算符, 如果操作数在之前不是number,试图将其转换为number

console.log( +'3' ); // 3

console.log( '3' ); // '3'

console.log(+true); // 1

位运算符(Bitwise operators)

位运算符将它的操作数视为32位元的二进制串(0和1组成)而非十进制八进制或十六进制数.例如:十进制数字9用二进制表示为1001,位运算符就是在这个二进制表示上执行运算,但是返回结果是标准的JavaScript数值.

下表总结了 JavaScript的位运算符.

表 3.4 位运算符
Operator Usage Description
按位与 AND a & b

在a,b的位表示中,每一个对应的位都为1则返回1, 否则返回0.

按位或 OR a | b 在a,b的位表示中,每一个对应的位,只要有一个为1则返回1, 否则返回0.
按位异或 XOR a ^ b 在a,b的位表示中,每一个对应的位,两个不相同则返回1,相同则返回0.
按位非 NOT ~ a 反转被操作数的位。
左移 shift a << b 将a的二进制串向左移动b位,右边移入0.
算术右移 a >> b

把a的二进制表示向右移动b位,丢弃被移出的所有位.

(译注:算术右移左边空出的位是根据最高位是0和1来进行填充的)

无符号右移

(左边空出位用0填充)

a >>> b 把a的二进制表示向右移动b位,丢弃被移出的所有位,并把左边空出的位都填充为0

位逻辑运算符(Bitwise logical operators)

概念上来讲, 位逻辑运算符工作流程如下:

  • 操作数被转换为32bit整數,以位序列(0和1组成)表示.若超過32bits,則取低位32bit,如下所示:
Before: 11100110111110100000000000000110000000000001
After:              10100000000000000110000000000001
  • 第一个操作数的每一位都与第二个操作数的对应位组对: 第一位对应第一位,第二位对应第二位,以此类推.
  • 运算符被应用到每一对"位"上, 最终的运算结果由每一对“位”的运算结果组合起来.

例如,十进制数9的二进制表示是1001,十进制数15的二进制表示是1111.因此,当位运算符应用到这两个值时,结果如下:

表 3.5 位运算符范例
表达式 结果 二进制描述
15 & 9 9 1111 & 1001 = 1001
15 | 9 15 1111 | 1001 = 1111
15 ^ 9 6 1111 ^ 1001 = 0110
~15 -16 ~00000000...00001111 = 11111111...11110000
~9 -10 ~00000000...00001001 = 11111111...11110110

注意位运算符“非”将所有的32位取反,而值的最高位(最左边的一位)为1则表示负数(2-补码表示法).

移位运算符(Bitwise shift operators)

移位运算符带两个操作数:第一个是待移位的数,第二个是指定第一个数要被移多少位的数. 移位的方向由运算符来控制.

移位运算符列表如下.

表 3.6 移位运算符
运算符 描述 范例
<<
(左移位)
将第一个操作数向左移动指定数量的位. 左边移出位被抛弃. 左边移出的几位被丢弃.右边多出的空位由0补齐 9<<2产生36,因为1001移位2比特向左变为100100,它是36。
>>
(带符号右移)
将第一个操作数向右移动指定数量的位. 右边移出位被抛弃. 左边多出的空位由原值的最左边数字补齐. 9>>2产量2,因为1001移位2位向右变为10,其是2。同样,-9>>2产量-3,由于符号被保留。
>>>
(补零右移)
将第一个操作数向右移动指定数量的位. 右边移出位被抛弃. 左边多出的空位由0补齐. 19>>>2 yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result.

逻辑运算符(Logical operators)

逻辑运算符常用于布尔(逻辑)值之间; 当操作数都是布尔值时,返回值也是布尔值。 不过实际上&&和||返回的是一个特定的操作数的值,所以当它用于非布尔值的时候,返回值就可能是非布尔值。 逻辑运算符的描述如下。

表 3.6 逻辑运算符
运算符 范例 描述
逻辑与 (&&) expr1 && expr2 (逻辑与) 如果expr1能被转换为false,那么返回expr1;否则,返回expr2。因此,&&用于布尔值时,当操作数都为true时返回true;否则返回false.
逻辑或 (||) expr1 || expr2 (逻辑或) 如果expr1能被转换为true,那么返回expr1;否则,返回expr2。因此,||用于布尔值时,当任何一个操作数为true则返回true;如果操作数都是false则返回false。
逻辑非 (!) !expr (逻辑非) 如果操作数能够转换为true则返回false;否则返回true。

能被转换为false的值有null, 0, NaN, 空字符串("")和undefined

下面是&&(逻辑与)操作符的示例。

var a1 =  true && true;     // t && t returns true
var a2 =  true && false;    // t && f returns false
var a3 = false && true;     // f && t returns false
var a4 = false && (3 == 4); // f && f returns false
var a5 = "Cat" && "Dog";    // t && t returns Dog
var a6 = false && "Cat";    // f && t returns false
var a7 = "Cat" && false;    // t && f returns false

下面是||(逻辑或)操作符的示例。

var o1 =  true || true;     // t || t returns true
var o2 = false || true;     // f || t returns true
var o3 =  true || false;    // t || f returns true
var o4 = false || (3 == 4); // f || f returns false
var o5 = "Cat" || "Dog";    // t || t returns Cat
var o6 = false || "Cat";    // f || t returns Cat
var o7 = "Cat" || false;    // t || f returns Cat

下面是!(逻辑非)操作符的示例。

var n1 = !true;  // !t returns false
var n2 = !false; // !f returns true
var n3 = !"Cat"; // !t returns false

短路求值(Short-circuit evaluation)

作为逻辑表达式进行求值是从左到右,它们是为可能的“短路”的出现而使用以下规则进行测试:

  • false && anything    // 被短路求值为false
  • true || anything       // 被短路求值为true

逻辑的规则,保证这些评估是总是正确的。请注意,上述表达式的任何一部分不评估,所以这样做的任何副作用不生效。

字符串运算符(String operators)

除了比较操作符,它可以在字符串值中使用,连接操作符(+)连接两个字符串值相连接,返回另一个字符串,它是两个操作数串的结合。

For example,

console.log( "my " + "string " + 2); // "my string 2"

简写操作符 '+='  可以用来拼接字符串,例如:

var myString = "alpha";

myString += "bet"; // evaluates to "alphabet" and assigns this value to mystring.

条件运算符(Conditional (ternary) operator)

条件运算符(conditional operator)是JavaScript中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为:

condition ? val1 : val2

如果condition为true,则结果取val1。否则为val2。你能够在任何允许使用标准运算符的地方使用条件运算符。

例如,

var status = (age >= 18) ? "adult" : "minor";

当age大于等于18的时候,语句将“adult”赋值给status;否则将“minor”赋值给status。

逗号操作符(Comma operator)

逗号操作符(comma operator)( , )对两个操作数进行求值并返回第二个操作数的值。它常常用在for循环中,在每次循环时对多个变量进行更新。

For example, if a is a 2-dimensional array with 10 elements on a side, the following code uses the comma operator to increment two variables at once. The code prints the values of the diagonal elements in the array:

for (var i = 0, j = 9; i <= j; i++, j--)
  console.log("a[" + i + "][" + j + "]= " + a[i][j]);

一元操作符(Unary operators)

一元操作符仅对应一个操作数。

delete

delete操作符, 删除一个对象(an object)或一个对象的属性(an object's property)或者一个数组中某一个键值(an element at a specified index in an array)。语法如下:

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement

objectName是一个对象名, property 是一个已经存在的属性, index是数组中的一个已经存在的键值的索引值.

第四行的形式只在with声明的状态下是合法的, 从对象中删除一个属性。

不推荐使用,并在ECMAScript中5严格模式是被禁止的。推荐的替代方案是分配要访问到一个临时变量,其属性的对象。

你能使用 delete 删除各种各样的隐式声明(implicity declared), 但是被var声明的除外 .

如果 delete 操作成功, 属性或者元素会变成 undefined. 如果 delete可行会返回true,如果不成功返回false.

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // create property h
delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var)
delete Math.PI; // returns false (cannot delete predefined properties)
delete myobj.h; // returns true (can delete user-defined properties)
delete myobj;   // returns true (can delete if declared implicitly)
删除数组元素(deleting array elements)

删除数组中的元素时,数组的长度是不变的,例如delete a[3], a[4]  ,a[4] 和a[3] 仍然存在变成了undefined.

delete 删除数组中的一个元素, 这个元素就不在数组中了. 例如, trees[3]被删除,trees[3] 仍然可寻址并返回undefined.

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // this does not get executed(不会被执行)
}

如果想让数组中存在一个元素但是是undefined值,使用undefined关键字而不是delete操作. 如下: trees[3]分配一个undefined,但是这个数组元素仍然存在:

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // this gets executed(会被执行)
}

typeof

typeof operator 可用下面2种方式使用:

typeof operand
typeof (operand)

typeof 操作符返回一个表示 operand 类型的字符串值。operand 可为字符串、变量、关键词或对象,其类型将被返回。operand 两侧的括号为可选。

假设你定义了如下的变量:

var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();

typeof 操作符将会返回如下的结果:

typeof myFun;     // returns "function"
typeof shape;     // returns "string"
typeof size;      // returns "number"
typeof today;     // returns "object"
typeof dontExist; // returns "undefined"

对于关键词 true 和 null, typeof 操作符将会返回如下结果:

typeof true; // returns "boolean"
typeof null; // returns "object"

对于一个数值或字符串, typeof 操作符将会返回如下结果:

typeof 62;            // returns "number"
typeof 'Hello world'; // returns "string"

对于属性值,typeof 操作符将会返回属性所包含值的类型:

typeof document.lastModified; // returns "string"
typeof window.length;         // returns "number"
typeof Math.LN2;              // returns "number"

对于方法和函数,typeof 操作符将会返回如下结果:

typeof blur;        // returns "function"
typeof eval;        // returns "function"
typeof parseInt;    // returns "function"
typeof shape.split; // returns "function"

对于预定义的对象,typeof 操作符将会返回如下结果:

typeof Date;     // returns "function"
typeof Function; // returns "function"
typeof Math;     // returns "object"
typeof Option;   // returns "function"
typeof String;   // returns "function"

void

void 运算符运用方法如下:

void (expression)
void expression

void运算符,表明一个运算没有返回值。expression是javaScript表达式,括号中的表达式是一个可选项,当然使用该方式是一种好的形式。

你可以使用void运算符指明一个超文本链接。该表达式是有效的,但是并不会在当前文档中进行加载。

如下创建了一个超链接文本,当用户单击该文本时,不会有任何效果。

<a href="javascript:void(0)">Click here to do nothing</a>

The following code creates a hypertext link that submits a form when the user clicks it.

<a href="javascript:void(document.form.submit())">
Click here to submit</a>

Relational operators

A relational operator compares its operands and returns a Boolean value based on whether the comparison is true.

in

in operator, 如果指定的属性(property)在指定的对象(object)中会返回true,语法如下:

propNameOrNumber in objectName

propNameOrNumber在这里可以是一个代表着属性名的字符串或者是一个代表着数组索引的数值表达式,而objectName则是一个对象名.

下面的例子是 in 操作的常见用法.

// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // returns true
3 in trees;        // returns true
6 in trees;        // returns false
"bay" in trees;    // returns false (you must specify the index number,
                   // not the value at that index)
"length" in trees; // returns true (length is an Array property)

// Predefined objects
"PI" in Math;          // returns true
var myString = new String("coral");
"length" in myString;  // returns true

// Custom objects
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // returns true
"model" in mycar; // returns true

instanceof

instanceof operator, 如果对象是某种指定类型(object type)返回true.语法如下:

objectName instanceof objectType

objectName 是对象的名称相较于objectType,objectType是对象的类型, 例如DateArray.

当你需要确认一个对象在运行时的类型时使用instanceof.例如, 抓取异常, 你可以根据抛出异常的类型分类处理异常代码.

例如, 下面的代码使用instanceof去判断 theDay是否是一个 Date 对象. 因为theDay是一个Date对象, 所以if中的代码会执行.

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // statements to execute 执行
}

运算符优先级(Operator precedence)

运算符的优先级确定计算表达式时,他们的应用顺序。您可以通过使用括号改写运算符优先级。

下表描述符的优先级,从最高到最低。

根据相关讨论,此表被推翻列出运营商在递减优先顺序。

Table 3.7 Operator precedence
Operator type Individual operators
member . []
call / create instance () new
negation/increment ! ~ - + ++ -- typeof void delete
multiply/divide * / %
addition/subtraction + -
bitwise shift << >> >>>
relational < <= > >= in instanceof
equality == != === !==
bitwise-and &
bitwise-xor ^
bitwise-or |
logical-and &&
logical-or ||
conditional ?:
assignment = += -= *= /= %= <<= >>= >>>= &= ^= |=
comma ,

该表的更详细的版本,完整的链接到每个运营商的其他详细信息,可在 JavaScript 参考手册 中找到。

表达式(Expressions)

表达式是代码的任何有效的单元解析为一个值。

从概念上讲,有两种类型的表达式:那些值分配给一个变量和那些仅仅有一个值。

表达式x=7是第一类型的一个例子。该表达式使用=运算符将值7赋予变量x。表达自己的计算结果为七人。

代码3 + 4是第二个表达式类型的一个例子。该表达式使用+运算符不分配结果,七加三,四在一起,给一个变量。

JavaScript有以下表达式类型:

  • 算数: 得出一个数字, 例如 3.14159. (通常使用 arithmetic operators.)
  • 字符串: 得出一个字符串, 例如, "Fred" 或 "234". (通常使用 string operators.)
  • 逻辑值: 得出true或者false. (经常涉及到 logical operators.)
  • 基本表达式: javascript中基本的关键字和一般表达式。
  • 左端表达式: 分配给左值。

基本表达式(Primary expressions)

this

使用this keyword关键字来指代当前对象(current object),通常,this指代的是方法中正在被调用的对象. 用法如下

this["propertyName"]
this.propertyName

Example 1.
假设一个用于验证对象value属性的validate函数,传参有对象,最高值和最低值。

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    console.log("Invalid Value!");
}

你可以在任何表格元素的onchange时间处理中调用validat函数,用this来指代当前的表格元素,用例如下,

<p>Enter a number between 18 and 99:</p>
<input type="text" name="age" size=3 onChange="validate(this, 18, 99);">

Example 2.
当和表单的属性相结合时,this.form可以指代当前对象的父元素表单。例如在以下例子中,表单myFrom包含了一个文本对象和一个按钮。当用户点击按钮的时候,文本对象的value值将会变成表格的名字。按钮的onClick处理事件使用this.form来指代父元素表单myForm。

<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
<P>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value = this.form.name;">
</FORM>
分组 操作符

分组操作符控制了表达式中计算的优先级. 举例来说, 你可以重写先乘除后加减的顺序,转而先计算加法。

var a = 1;
var b = 2;
var c = 3;

// 默认优先级
a + b * c     // 7
// 默认是这样计算的
a + (b * c)   // 7

// 现在使加法优先于乘法
(a + b) * c   // 9

// 这等价于
a * c + b * c // 9
Comprehensions

Comprehensions are an experimental JavaScript feature, targeted to be included in a future ECMAScript version. There are two versions of comprehensions:

[for (x of y) x]
Array comprehensions.
(for (x of y) y)
Generator comprehensions.

Comprehensions exist in many programming languages and allow you to quickly assemble a new array based on an existing one, for example.

[for (i of [ 1, 2, 3 ]) i*i ]; 
// [ 1, 4, 9 ]

var abc = [ "A", "B", "C" ];
[for (letters of abc) letters.toLowerCase()];
// [ "a", "b", "c" ]

Left-hand-side expressions

Left values are the destination of an assignment.

new

你可以使用new operator 创建一个自定义类型或者是 Array, Boolean, Date, Function, Image, Number, Object, Option, RegExpString这些预置类型的对象实例。在服务端,你也可以和DbPool, Lock, File, SendMail一起使用,用法如下:

var objectName = new objectType([param1, param2, ..., paramN]);

你也可以使用对象初始化器创建对象实例, 具体描述见 using object initializers.

点击 new operator 查看Core JavaScript Reference里更多关于new 操作符信息。

 

文档标签和贡献者

 最后编辑者: sgr,