转载

Before Coding [13] - JavaScript - 表达式和运算符

本章主要介绍 JavaScript 的表达式和运算符，包括了赋值，比较，算数，按位，逻辑，字符串，三元等等。列举所有的运算符，但是不会全部讲解，只讲解实际编程中会用到的几种。

运算符（Operators）

JavaScript 拥有如下类型的运算符：

赋值运算符
比较运算符
算数运算符
按位运算符
逻辑运算符
字符串运算符
条件 (三元) 运算符
逗号运算符
一元运算符
关系运算符

JavaScript 拥有二元和一元运算符，和一个特殊的三元运算符（条件运算符）。

一个二元运算符需要两个操作数，分别在运算符的前面和后面：

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

例如, 3+4 或 x*y 。

一个一元运算符需要一个在运算符前面或后面的操作数：

运算符    操作数
operator operand

或

操作数   运算符
operand operator

例如, x++ 或 ++x 。

赋值运算符

一个赋值运算符赋一个基于它右边操作数值的值给它左边的操作数。最简单的赋值运算符是等于（ = ），将右边的操作数值赋给左边的操作数。那么 x = y 就是将 y 的值赋给 x 。

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

名字	速记操作	等同于
赋值	`x = y`	`x = y`
加法赋值	`x += y`	`x = x + y`
减法赋值	`x -= y`	`x = x - y`
乘法赋值	`x *= y`	`x = x * y`
除法赋值	`x /= y`	`x = x / y`
求余赋值	`x %= y`	`x = x % y`
求幂赋值	`x **= y`	`x = x ** y`
左移位赋值	`x <<= y`	`x = x << y`
右移位赋值	`x >>= y`	`x = x >> y`
无符号右移位赋值	`x >>>= y`	`x = x >>> y`
按位与赋值	`x &= y`	`x = x & y`
按位异或赋值	`x ^= y`	`x = x ^ y`
按位或赋值	`x	= y`	`x = x	y`

比较运算符

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

var var1 = 3, var2 = 4;

运算符	描述	返回true的示例1	返回true的示例2
等于 ( `==` )	如果两边操作数相等时返回true。	3 == var1	“3” == var1
不等于 ( `!=` )	如果两边操作数不相等时返回true。	var1 != 4	var2 != “3”
全等于 ( `===` )	两边操作数相等且类型相同时返回true。	3 === var1	4 === var2
不全等于 ( `!==` )	两边操作数不相等或类型不同时返回true。	var1 !== “3”	3 !== ‘3’
大于 ( `>` )	左边的操作数大于右边的操作数返回true。	var2 > var1	“12” > 2
大于等于 ( `>=` )	左边的操作数大于或等于右边的操作数返回true。	var2 >= var1	var1 >= 3
小于 ( `<` )	左边的操作数小于右边的操作数返回true。	var1 < var2	“2” < 12
小于等于 ( `<=` )	左边的操作数小于或等于右边的操作数返回true。	var1 <= var2	var2 <= 5

算术运算符

算术运算符使用数值作为操作数并返回一个数值，标准的算术运算符就是加减乘除( + - * / )。当操作数是浮点数时，这些运算符表现得跟它们在大多数编程语言中一样，例如:

console.log(1 / 2); /* prints 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* also this is true */

另外，JavaScript 还提供了如下的算术运算符：

求余（ `%` ）

二元运算符，返回相除之后的余数。

如：13 % 5 返回 3

自增（ `++` ）

一元运算符，将操作数的值加一。

如果放在操作数前面 ( ++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
var y=3;
console.log(y--);//输出3

一元负值符（ `-` ）

一元运算符，返回操作数的负值。

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

位运算符

位运算符有七种，了解即可，具体用法不作解释：

按位与： a & b
按位或： a | b
按位异或： a ^ b
按位反： ~a
左移： a << b
右移： a >> b
无符号右移： a >>> b

逻辑运算符

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

逻辑与（ `&&` ）

对于 expr1 && expr2 ，如果 expr1 能被转换为 false，那么返回 expr1；否则，返回 expr2 。因此， && 用于布尔值时，当操作数都为 true 时返回 true；否则返回 false。

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

逻辑或（ `||` ）

对于 expr1 || expr2 ，如果 expr1 能被转换为 true，那么返回 expr1；否则，返回 expr2 。因此， || 用于布尔值时，当任何一个操作数为 true 则返回 true；如果操作数都是 false 则返回 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

逻辑非（ `~` ）

如果操作数能够转换为 true 则返回 false；否则返回 true。

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

条件运算符

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

condition ? val1 : val2

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

例如，

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

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

运算符的优先级

运算符的优先级确定计算表达式时，他们的应用顺序。您可以通过使用括号改写运算符优先级。下表描述符的优先级，从最高到最低：

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	`,`