JavaScript红宝书02|这些运算符你都了解吗？

一、一元运算符

为什么叫一元运算符：表示只能操作一个值的操作符

1. 递增和递减操作符

分为前置型和后置型。前置型先做运算再保存值，后置型先保存值再做运算。

	var num1 = 2; 
	var num2 = 20; 
	var num3 = --num1 + num2; // 等于 21 
	var num4 = num1 + num2; // 等于 21 

	var num1 = 2; 
	var num2 = 20; 
	var num3 = num1-- + num2; // 等于 22 
	var num4 = num1 + num2; // 等于 21

	var s1 = "2"; 
	var s2 = "z"; 
	var b = false; 
	var f = 1.1; 
	var o = { 
 		valueOf: function() { 
 		return -1; 
	 } 
}; 
	s1++; // 值变成数值 3 
	s2++; // 值变成 NaN 
	b++; // 值变成数值 1 
	f--; // 值变成 0.10000000000000009（由于浮点舍入错误所致）
	o--; // 值变成数值-2 ，用于对象时，会调用对象的 valueOf()方法

2. 一元加和减操作符

非数值时，会像Number()转型函数进行转为数值。

	var s1 = "01"; 
	var s2 = "1.1"; 
	var s3 = "z"; 
	var b = false; 
	var f = 1.1; 
	var o = { 
		 valueOf: function() { 
		 return -1; 
	 } 
	}; 
	s1 = +s1; // 值变成数值 1 
	s2 = +s2; // 值变成数值 1.1 
	s3 = +s3; // 值变成 NaN 
	b = +b; // 值变成数值 0 
	f = +f; // 值未变，仍然是 1.1 
	o = +o; // 值变成数值-1 
	------------------------------ 
	s1 = -s1; // 值变成了数值-1 
	s2 = -s2; // 值变成了数值-1.1 
	s3 = -s3; // 值变成了 NaN 
	b = -b; // 值变成了数值 0 
	f = -f; // 变成了-1.1 
	o = -o; // 值变成了数值 1 

二、位运算符

位操作符用于在最基本的层次上，即按内存中表示数值的位来操作数值。
对于有符号的整数，32 位中的前 31 位用于表示整数的值。第 32 位用于表示数值的符号：0 表示正数，1 表示负数。

1. 按位非（NOT）(~)

符号~, 返回数值的反码。

	var num1 = 25; // 二进制 00000000000000000000000000011001 
	var num2 = ~num1; // 二进制 	11111111111111111111111111100110 
	alert(num2); // -26 

2. 按位与（AND）(&)

符号&, 运算规则：

	var result = 25 & 3; 
	alert(result); //1

3. 按位或（OR）(|)

符号|, 运算规则：

	var result = 25 | 3; 
	alert(result); //27 

4. 按位异或（XOR）(^)

符号^, 运算规则：相同为0，不同为1

5.左移(<<)

符号<<, 左移几位会在右边补几个0

	var oldValue = 2; // 等于二进制的 10 
	var newValue = oldValue << 5; // 等于二进制的 1000000，十进制的 64

6.有符号的右移(>>)

符号>>,会将数值向右移动，但保留符号位（即正负号标记）

var oldValue = 64; // 等于二进制的 1000000 
var newValue = oldValue >> 5; // 等于二进制的 10 ，即十进制的 2 

7. 无符号右移(>>>)

符号>>>,表示，这个操作符会将数值的所有 32 位都向右移动。对正数来说，无符号右移的结果与有符号右移相同。

	var oldValue = -64; // 等于二进制的 		11111111111111111111111111000000 
	var newValue = oldValue >>> 5; // 等于十进制的 134217726

三、逻辑运算符的小细节

1. 逻辑非（!）

首先会将它的操作数转换为一个布尔值(类似Boolean()函数)，然后再对其求反，结果是布尔值。

	alert(!false); // true 
	alert(!"blue"); // false 
	alert(!0); // true 
	alert(!NaN); // true 
	alert(!""); // true 
	alert(!12345); // false 

2. 逻辑与（&&）

规则：全为真才是真

	var found = true; 
	var result = (found && someUndefinedVariable); // 这里会发生	错误
	alert(result); // 这一行不会执行
	------------------------------------
	var found = false; 
	var result = (found && someUndefinedVariable); // 不会发生错误
	alert(result); // 会执行（"false"）

3. 逻辑或（||）

规则：只要一个为真就为真

	var found = true; 
	var result = (found || someUndefinedVariable); // 不会发生错误
	alert(result); // 会执行（"true"）
	---------------------------------------
	var found = false; 
	var result = (found || someUndefinedVariable); // 这里会发生错误
	alert(result); // 这一行不会执行

❗❗ 注意逻辑与和逻辑或是一个短路运算符

四、你可能不知道的操作符小细节

1. 乘法运算符：

① 如果有一个操作数是 NaN，则结果是 NaN
② 如果是 Infinity 与 0 相乘，则结果是 NaN
③ 如果是 Infinity 与 Infinity 相乘，则结果是 Infinity
④ 如果是 Infinity 被 Infinity 除，则结果是 NaN

	var num1 = 5; 
	var num2 = 10; 
	var message = "The sum of 5 and 10 is " + num1 + num2; 
	alert(message); // "The sum of 5 and 10 is 510"
	//因为每个加法操作是独立执行的,(num1 + num2)会变成15

2. 关系运算符：

① 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。
② 如果一个操作数是数值，则将另一个操作数转换为数值，然后执行数值比较。

	var result = "23" < "3"; //true, "2"的字符编码是 50，而"3"的字符编码是 51
	var result = "23" < 3; //false ，字符串"23"会被转换成数值 23，然后再与 3 进行比较
	var result = "a" < 3; // false，母"a"不能转换成合理的数值，因此就被转换成了 NaN。
	//任何操作数与 NaN 进行关系比较，结果都是 false!!

3.==和===

==和!= ，只比较值，在比较时会对数值进行强制转换再比较。
注意点：
① null 和 undefined 是相等的
② 不能将 null 和 undefined 转换成其他任何值。

===比较两边的值和类型，比较时不会进行类型的转换。

	var result1 = ("55" != 55); //false，因为转换后相等
	var result2 = ("55" !== 55); //true，因为不同的数据类型不相等