JavaScript 运算符
一、 JavaScript 运算符
JavaScript 拥有如下类型的运算符。
1) 赋值运算符(Assignment operators [əˈsaɪnmənt] ['ɒpəreɪtəz])
2) 比较运算符(Comparison operators [kəmˈpærɪsən])
3) 算数运算符(Arithmetic operators [əˈrɪθmɪtɪk])
4) 位运算符(Bitwise operators [bɪt'waɪz])
5) 逻辑运算符(Logical operators [ˈlɑ:dʒɪkl])
6) 字符串运算符(String operators)
7) 条件（三元）运算符(Conditional operator [kənˈdɪʃənəl)
8) 逗号运算符(Comma operator [ˈkɑ:mə])
9) 一元运算符(Unary operators [ˈju:nəri])
10) 关系运算符(Relational operator [rɪ'leɪʃənl])
1. 赋值运算符(Assignment operators)
一个赋值运算符将它右边操作数的值赋给它左边的操作数。
最简单的赋值运算符是等于（=），它将右边的操作数值赋给左边的操作数。那么 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
|
2. 比较运算符
比较运算符比较它的操作数并返回一个基于表达式是否为真的逻辑值。操作数可以是数字，字符串，逻辑，对象值。字符串比较是基于标准的字典顺序，使用Unicode值。
在多数情况下，如果两个操作数不是相同的类型， JavaScript 会尝试转换它们为恰当的类型来比较。这种行为通常发生在数字作为操作数的比较。
类型转换的例外是使用 === 和 !== 操作符，它们会执行严格的相等和不相等比较。这些运算符不会在检查相等之前转换操作数的类型。下面的表格描述了该示例代码中的各比较运算符
var var1 = 3;
var var2 = 4;
|
运算符
|
描述
|
返回true的示例
|
|
相等 Equal (==)
|
如果两边操作数相等时返回true。
|
3 == var1
"3" == var1
3 == '3'
|
|
不等于 Not equal (!=)
|
如果两边操作数不相等时返回true
|
var1 != 4
var2 != "3"
|
|
全等 Strict equal (===)
|
两边操作数相等且类型相同时返回true。
|
3 === var1
|
|
不全等 Strict not equal (!==)
|
两边操作数不相等或类型不同时返回true。
|
var1 !== "3"
3 !== '3'
|
|
大于 Greater than (>)
|
左边的操作数大于右边的操作数返回true
|
var2 > var1
"12" > 2
|
|
左边的操作数大于或等于右边的操作数返回true
|
var2 >= var1
var1 >= 3
|
|
|
小于 Less than (<)
|
左边的操作数小于右边的操作数返回true
|
var1 < var2
"2" < 12
|
|
左边的操作数小于或等于右边的操作数返回true
|
var1 <= var2
var2 <= 5
|
equal [ˈikwəl] 相等的
注意: （=>） 不是运算符，而是箭头函数的标记符号 。
全等和等于的区别：
² 全等“===”运算符比较过程：
只有两个值类型相同并且值也相同的时候，它们才相等。
如果两个引用值指向同一个对象、数组或函数，则它们是相等的。如果指向不同的对象，则它们是不等的，尽管两个对象具有完全一样的属性。
如果两个值为字符串，且所含的对应位上的16位数完全相等，则它们相等。如果它们的长度或内容不同，则它们不等。两个字符串可能含义完全一样且所显示出的字符也一样，但具有不同编码的16位值。JavaScript并不对Unicode进行标准化的转换，因此像这样的字符串通过“==”和“===”运算符比较的结果也不相等。
² 相等“==”运算符比较过程（只比较值，不比较类型）
两个操作数类型相同并且值也相同，则它们相等。
两个操作数类型不相同但是值相同，它们也相等，如下：
1） 数字和字符串运算时，系统会先将字符串转换为数字，然后使用转换的数值进行比较。
2） 数字和布尔值比较，true会转换为1，false会转换为0再进行比较。
3） 数字和对象比较过程，第一步，调用对象自身的valueOf方法。如果返回原始类型的值，则直接对该值使用Number函数，转化为数字进行比较，不再进行后续步骤。
第二步，如果valueOf方法返回的还是对象，则改为调用对象自身的toString方法。如果toString方法返回原始类型的值，则对该值使用Number函数，不再进行后续步骤。
第三步，如果toString方法返回的是对象，就报错。
4） 另外：null和undefined相等；
5） 其它不同类型之间的比较，均不相等。例如：
var x = "1";
var y = [1];
console.log(x===y);//false
3. JavaScript 算术运算符
算术运算符使用数值(字面量或者变量)作为操作数并返回一个数值.标准的算术运算符就是加减乘除(+ - * /)。
当操作数是浮点数时，这些运算符表现得跟它们在大多数编程语言中一样（特殊要注意的是，除零会产生Infinity）。
|
算符
|
描述
|
例子
|
x 运算结果
|
y 运算结果
|
|
+
|
加法
|
x=y+2
|
7
|
5
|
|
-
|
减法
|
x=y-2
|
3
|
5
|
|
*
|
乘法
|
x=y*2
|
10
|
5
|
|
/
|
除法
|
x=y/2
|
2.5
|
5
|
|
%
|
取模（余数）
|
x=y%2
|
1
|
5
|
|
++
|
自增（i++，先赋值，后
|
x=++y
|
6
|
6
|
|
|
加加；++i，先加加，后赋值）
|
x=y++
|
5
|
6
|
|
--
|
自减
|
x=--y
|
4
|
4
|
|
|
|
x=y--
|
5
|
4
|
其它算术运算符
|
一元负值符(-)
|
一元运算符,返回操作数的负值.
|
var x=3; console.log(-x); //输入-3
|
|
一元正值符(+)
|
一元运算符, 如果操作数在之前不是number，试图将其转换为number
|
console.log( +'3' ); // 3
|
|
console.log( '3' ); // '3'
|
||
|
console.log(+true); // 1
|
||
|
指数运算符(**)
|
计算 base(底数) 的 exponent(指数)次方, 表示为baseexponent
|
2 ** 3 returns 8.
|
|
10 ** -1 returns 0.1.
|
4. 逻辑运算符
逻辑运算符常用于布尔（逻辑）值之间; 当操作数都是布尔值时，返回值也是布尔值。
不过实际上&&和||返回的是一个特定的操作数的值，所以当它用于非布尔值的时候，返回值就可能是非布尔值。
|
运算符
|
范例
|
描述
|
|
逻辑与 (&&)
|
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
短路求值
作为逻辑表达式进行求值是从左到右，它们是为可能的“短路”的出现而使用以下规则进行测试：
false && anything // 被短路求值为false
true || anything // 被短路求值为true
anything [ˈɛniˌθɪŋ] 任何东西
逻辑的规则，保证这些评估是总是正确的。请注意，上述表达式的anything部分不会被求值，所以这样做不会产生任何副作用。
5. 字符串运算符
除了比较操作符，它可以在字符串值中使用，连接操作符（+）连接两个字符串值相连接，返回另一个字符串，它是两个操作数串的结合。
例如，
console.log("my " + "string"); // console logs the string "my string".
简写操作符 += 也可以用来拼接字符串，例如：
var myString = "alpha";
myString += "bet"; // 返回 "alphabet"
6. 条件（三元）运算符
条件运算符是JavaScript中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：
条件 ? 值1 : 值2
如果条件为真，则结果取值1。否则为值2。你能够在任何允许使用标准运算符的地方使用条件运算符。
例如，
var status = (age >= 18) ? "adult" : "minor";
当 age 大于等于18的时候，将“adult”赋值给 status；否则将“minor”赋值给 status。
7. 逗号操作符
逗号操作符（,）对两个操作数进行求值并返回最终操作数的值。它常常用在 for 循环中，在每次循环时对多个变量进行更新。
例如，假如 a 是一个二维数组，每个维度各有10个元素，以下代码利用逗号操作符来同时改变两个变量的值。这段代码的功能是打印出该二维数组的对角线元素的值：
var x = [0,1,2,3,4,5,6,7,8,9]
var a = [x, x, x, x, x];
for (var i = 0, j = 9; i <= j; i++, j--)
console.log('a[' + i + '][' + j + ']= ' + a[i][j]);
8. 一元操作符
一元操作符仅对应一个操作数。
8.1 typeof
typeof操作符 可通过下面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"
8.2 delete
delete操作符，删除一个对象或一个对象的属性或者一个数组中某一个键值。语法如下:
delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement
objectName是一个对象名，property 是一个已经存在的属性，index是数组中的一个已经存在的键值的索引值。
第四行的形式只在with声明的状态下是合法的， 从对象中删除一个属性。
你能使用 delete 删除各种各样的隐式声明， 但是被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)
9. 关系操作符
关系操作符对操作数进行比较，根据比较结果真或假，返回相应的布尔值。
9.1 instanceof
如果所判别的对象确实是所指定的类型，则返回true。其语法如下：
objectName instanceof objectType
objectName 是需要做判别的对象的名称,而objectType是假定的对象的类型, 例如Date或 Array.
当你需要确认一个对象在运行时的类型时，可使用instanceof. 例如，需要 catch 异常时，你可以针对抛出异常的类型，来做不同的异常处理。
9.2 in
in操作符，如果所指定的属性确实存在于所指定的对象中，则会返回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
5 in trees; // returns false，索引只到4
"bay" in trees; // returns false (必须指定索引号, "bay"不是索引的值)
"length" in trees; // returns true (length 是数组属性)
// 预定义对象
"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
10. 位运算符
位运算符将它的操作数视为32位元的二进制串（0和1组成）而非十进制八进制或十六进制数。
例如：十进制数字9用二进制表示为1001，位运算符就是在这个二进制表示上执行运算，但是返回结果是标准的JavaScript数值。
|
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
|
位运算符范例
|
表达式
|
结果
|
二进制描述
|
|
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
|
移位运算符
移位运算符带两个操作数：第一个是待移位的数，第二个是指定第一个数要被移多少位的数。移位的方向由运算符来控制.
移位运算符把操作数转为32bit整数，然后得出一个与待移位数相同种类的值。
移位运算符列表如下：
|
运算符
|
描述
|
范例
|
|
<<(左移位)
|
将第一个操作数向左移动指定数量的位. 左边移出位被抛弃. 左边移出的几位被丢弃.右边多出的空位由0补齐
|
9<<2产生36，因为1001移位2比特向左变为100100，它是36。
|
|
>>(带符号右移)
|
将第一个操作数向右移动指定数量的位. 右边移出位被抛弃. 左边多出的空位由原值的最左边数字补齐.
|
9>>2产生2，因为1001移位2位向右变为10，其是2。同样，-9>>2产生-3，由于符号被保留。
|
|
>>>(补零右移)
|
将第一个操作数向右移动指定数量的位. 右边移出位被抛弃. 左边多出的空位由0补齐.
|
19>>>2产生4，因为10011移位2位向右变为100，它是4。对非负数值，补零右移和带符号右移产生相同结果。
|
二、 知识拓展：
1. 运算符优先级
运算符的优先级，用于确定一个表达式的计算顺序。在你不能确定优先级时，可以通过使用括号显式声明运算符的优先级。
下表列出了描述符的优先级，从最高到最低。
|
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
|
,
|
2. 二进制
二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”。 它是计算技术中广泛采用的一种数制。
2.1二进制法则：
乘法法则： 0×0=0，0×1=0，1×0=0，1×1=1
除法法则： 0÷1=0，1÷1=1；除法应注意： 0÷0 =0(无意义)，0÷1 =0，1÷0 =0(无意义)
加法法则： 0+0=0，0+1=1，1+0=1，1+1=10
减法法则： 0-0 =0，1-0=1，1-1=0，0-1=1此时有借位（需从上一位借值，当需要向上一位借数时，必须把上一位的1看成下一位的（2）实际是10）。比如：10100-1010=1010
二进制算法：
二进制的或运算：遇1得1
二进制的与运算：遇0得0
二进制的非运算：各位取反
总结：二进制与十进制的算法格式相同，只不过十进制是逢十进一，而二进制是逢二进一。
十进制转二进制、十六进制：
二进制与八进制十六进制转换技巧：
二进制从最低位开始每三位转换为十进制即为其对应八进制。
高位不足三位，补零。
同理二进制从最低位开始每四位转换为十进制即为其对应十六进制。
高位不足四位，补零。
例如 1001100₂ = 114₈ = 4C₁₆
001 001 100 转八进制时，高位补零。
0100 1100 转十六进制时，高位补零。
其它：
字节是电脑中的基本存储单位，根据计算机字长的不同，字具有不同的位数，现代电脑的字长一般是32位的，也就是说，一个字的位数是32。
二进制的负数：
比如：原码：14 即 00000000 00000000 00000000 00001110（高位不足这么多位的时候补零！）；
原码：一个整数按照绝对值的大小转化成二进制的数；
二进制中，负数以正数的补码表示
补码：反码加 1
反码：将二进制数按位取反
14的反码即原码取反（也就是1变0，0变1）：11111111 11111111 11111111 11110001
补码（-14）： 11111111 11111111 11111111 11110010
二进制<<左移运算符
将一个运算对象的各二进制位全部左移若干位（即：左边的二进制丢弃，右边补0）
14 的二进制 00000000 00000000 00000000 00001110左移2位 为
00000000 00000000 00000000 00111000 //56
-14的二进制（11111111 11111111 11111111 11110010）左移2位 为
11111111 11111111 11111111 11001000 结果为（-56）
总结：对于左移，直观的理解为，对于正数来说，左移1位相当于乘以2（但效率比乘法高）；对于负数来说，没有直观的理解。
>>右移运算符
将一个运算对象的各二进制位全部右移若干位，正数左补0，负数左补1.
4 >> 2 = 1;
-14 >> 2 = -4;
总结：对于右移，直观的理解为，对于正数来说，右1移相当于除以2（但效率比除法高）；对于负数来说，没有直观的理解。
题：
var a = 2+"3";
console.log(typeof a);
var b = !a + null;
console.log(typeof b);
var c = !true + "3"*2;
console.log(typeof c);
var d = a++ + b--;
console.log(typeof d);
var e = ![23]+1+(1<6);
console.log(typeof e);
重点：
// 1.赋值运算 = += 支持字符串拼接
// 2.比较运算符 == === 两个字符串比较大小，比较的是Unicode编码的序号，靠后的序号大
// 其他情况，所有数据都转换成数字进行比较
// NaN与数据比较的结果只能是false
// 3.算数运算符 所有数据都转换成数字进行数学运算（除字符串和+相连接的情况）
// i++ 先赋值，后运算 当前i===之前的i
// ++i 先运算，后赋值 当前i===之后的i
// 所有语句的运算都是变量在参与运算，一定要知道当前变量的值是多少
// 4.字符串运算符 +
// 5.逻辑运算符： && || ！
// 之前语句 && 之后语句 如果&&之前的语句结果可以转换成false，那么它的结果就是之前的语句，反之则是之后的语句
// 之前语句 || 之后语句 如果||之前的语句结果可以转换成true，那么它的结果就是之前的语句，反之则是之后的语句
