Javascript 基本概念（操作符）

摘要：对于有符号的整数，第一位是符号位正数，负数，后位表示数值。正数二进制表示，没有用到的位补，如用二进制表示为，第一位是符号位，后位均用补位，是有效位。按位非求反码，本质是求操作数的负值减一。

只能操作一个值的操作符叫一元操作符

++ and --

前置递增和递减，在语句求值之前改变数值的大小

后置递增和递减，在语句求值之后改变数值的大小

比如：

var age = 18;
var now = ++age - 10; // now = 9, age = 19
var now = age++ - 10;  // now = 9, age = 20

前置递增、递减和后置递增、递减可用于操作整数、浮点数、布尔值、字符串、对象，ECMAScript会根据前面提到过的各种数据类型转化成数值类型的规则，先将值转化为数值，然后加减1

一元+ and -

+放在数值前面，不会有任何影响，-使负数变为正数，正数变为负数，当一元+用在非数值前面，会试图将它们转化为数值，规则同之前讲过的，而一元-用在非数值前面，会首先将它们转化为数值，再变成相应的负数。

ECMAScript中的数值以IEEE-754 64 位格式存储，使用位操作符操作数值时，现将该数值转化为32位，然后进行计算，最后再转化成64位。
对于有符号的整数，第一位是符号位（0正数，1负数），后31位表示数值。

正数

二进制表示，没有用到的位补0，如18用二进制表示为00000000000000000000000000010010，第一位是符号位，后27位均用0补位，10010是有效位。

负数

二进制补码表示，计算一个数值如-18的补码需要三步：

求这个数值绝对值的二进制，即00000000000000000000000000010010

求二进制的反码（0为1,1为0），即11111111111111111111111111101101

加一，即11111111111111111111111111101110

注意(-18).toString(2)的结果是-10010而不是11111111111111111111111111101110，默认情况下ECMAScript中的整数都是有符号的，存在无符号整数，无符号整数能表示的数值更大。
对非数值应用一下讲述的位操作，会首先进行Number()转化，位操作视NaN Infinity为0
所有的按位操作符的操作数都会被转成补码形式的有符号32位整数。

按位非 ~

求反码，本质是求操作数的负值减一。
为了方便验证，我们用五位表示

取反码

abcde——1-a 1-b 1-c 1-d 1-e

负值减一

abcde——1-a 1-b 1-c 1-d 1-e——1-a 1-b 1-c 1-d 2-e
1-a 1-b 1-c 1-d 2-e - 1 = 1-a 1-b 1-c 1-d 1-e
可见是相等的。

按位与 &

将两个数值按位对齐，如果同一位上均为1，则返回结果的这一位为1，否则为0。
比如：
45 & 67; //1
00000000000000000000000000101101
00000000000000000000000001000011
结果为：
00000000000000000000000000000001

按位或 |

将两个数值按位对齐，如果同一位均为0，则返回结果的这一位为0，否则为1。

45 | 67; //111
0000000000000000000000000101101
0000000000000000000000001000011
结果为：
00000000000000000000000001101111

按位异或 ^

将两个数值按位对齐，如果同一位数值不同，则返回结果的这一位为1，若相同，则为0。
45 ^ 67; //110
0000000000000000000000000101101
0000000000000000000000001000011
结果为：
00000000000000000000000001101110

左移 <<

向左移动一定位数，不改变符号位，空出来的位置补0（补0的个数与移动位数相同）
45 ^ 5; //1440
0000000000000000000000000101101
结果为：
00000000000000000000010110100000

右移 >>

45 >> 5; //1
0000000000000000000000000101101
结果为：
00000000000000000000000000000001
向右移动一定位数，不改变符号位，空出来的位置补0（补0的个数与移动位数相同）

无符号右移 >>>

向右移动一定位数，改变符号位，空出来的位置补0（补0的个数与移动位数相同）

正数

同>>（用于填充空位的0与符号位相同，等于填充了符号位）

负数

无符号右移操作符会把负数的二进制码当成正数的二进制码
-64>>>25; // 127
11111111111111111111111111000000
结果为：
00000000000000000000000001111111

逻辑非 !

可以操作任何数据类型，首先对其取布尔值，然后取反

!!相当于Boolean可以返回这个值真正对应的布尔值。

逻辑与 &&

逻辑与有两个操作数，只有true && true才会返回true，可以操作任何数据类型。
如果有一个或两个操作数不是布尔值，逻辑与不一定返回布尔值，规则如下：

如果第一个是对象，返回第二个操作数

如果第二个是对象，在第一个求值结果为true时返回第二个

如果第一个是null，返回null

如果第一个是undefined，返回undefined

如果第一个是NaN，返回NaN

逻辑与是短路操作，如果第一个操作数可以决定求值结果，就不会对第二个操作数求值，当第一个操作数求值为false，则表达式结果为false。

逻辑或 ||

逻辑或有两个操作数，只有false || false才会返回false，可以操作任何数据类型。
如果有一个或两个操作数不是布尔值，逻辑或不一定返回布尔值，规则如下：

如果第一个操作数是对象，则返回第一个操作数

如果第一个对象的求值结果为false，则返回第二个操作数

如果两个操作数都是null，则返回null

如果两个操作数都是NaN，则返回NaN

如果两个操作数都是undefined，则返回undefined

逻辑或也是短路操作符，如果第一个求值结果为true，则返回true。
我们可以利用逻辑或的这一行为来避免为变量赋null 或undefined 值。

var myObject = preferredObject || backupObject;

如果preferredObject为null or undefined， 会将backupObject的值赋给myObject

如果参加乘性操作的操作符不是数值，会调用Number()将其转为数值，这一过程在这一节中不再赘述。

乘法 *

乘法遵循以下规则：

如果操作数都是数值，执行常规的乘法运算

有一个操作数是NaN，则结果是NaN

Infinity * 0; // NaN

Infinity与非0（包括无穷）相乘，结果为无穷

除法 /

除法遵循以下规则：

如果操作数都是数值，执行常规的除法运算

有一个操作数是NaN，则结果是NaN

Infinity/Infinity; // NaN

0/0; // NaN

非零的数除以0，结果为无穷

无穷被非零的数相除，结果为无穷

求模 %

求模遵循以下规则：

如果操作数都是数值，执行常规的求模运算

无穷大除以有限大的数值，余数运算结果为`NaN

有限大的数值除以0，余数运算结果为NaN

Infinity除以Infinity，余数运算结果为NaN

有限大的数值除以无穷大，余数运算结果为被除数

被除数是0，除数不为NaN或0，结果为0

5 / 0 % 5; // NaN
5 % 0; // NaN
5 / 0 % (5 / 0); // NaN
5 % (5 / 0); // 5
0 % 0; // NaN
0 % (5 / 0); //0
0 % 5; //0
0 % (5 % 0); //NaN

加法 +

如果两个操作数都是数值，则遵循以下规则：

Infinity + Infinity; // Infinity

-Infinity + (-Infinity); // -Infinity

-Infinity + Infinity; // NaN

+0 + (+0); // +0

-0 + (-0); //-0

-0 + (+0); // +0

如果有操作符是字符串，则遵循以下规则：

如果两个都是字符串，则将两个字符串拼接起来

如果只有一个是字符串，则把非字符操作数转化为字符串，拼接起来

忽视加法操作中的数据类型是ECMAScript 编程中最常见的一个错误。再来看一个例子：
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"

减法 -

减法运算遵循以下规则：

如果都是数值，执行常规减法操作

如果有一个是NaN，则结果是NaN

Infinity - Infinity; // NaN

-Infinity - (-Infinity); // NaN

Infinity - (-Infinity); //Infinity

-Infinity - Infinity; //-Infinity

+0 - (+0); // +0

+0-(-0); // -0

-0 - (-0); // +0

包括< > <= >=，遵循如下规则：

如果都是数值，进行数值大小比较

如果都是字符串，则比较字符编码值，有如下规则：

如果字符串相等返回值0

如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的编码差值

如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度。

如果一个是数值，则另一个转化成数值，然后比较

对象执行valueof()，如果没有，调用其toString()，然后按上述规则比较

举一些例子：

"23" < "3"; //true
"23" < 3; //false
"B" < "a"; //true，大写字母的字符编码全部小于小写字母的字符编码
"a" < 3; // false，"a"转化为NaN，NaN参与任何操作都返回NaN
"a" >= 3; //false

相等 == 和不相等 !=

先转换操作数，再比较相等性，转换的规则如下：

如果有一个操作数是布尔型，将其转化为数值

字符串与数值比较，字符串转化为数值

对象与非对象比较，调用对象的valueof()得到基本类型，再按以上规则比较

比较规则如下：

null == undefined; //true

不会转换undefined与null

NaN与任何操作数相等性比较，返回false，不相等性比较，返回true，包括NaN

如果都是对象，看是否指向同一对象

举一些例子：

undefined == 0; //false
null == 0; //false
NaN == NaN; //false
NaN != NaN; //false
true == 1; //true
false == 0; //true
"NaN" == NaN; // false

全等 === 和不全等 !==

不转换操作数，直接比较，比较规则除了第一条均相同

undefined === null ; // false

可以看出全等比相等要安全，不会强制转换。

variable = boolean_expression ? true_value : false_value;
boolean_expression 若为true，返回true_value，若为false，返回false_value

将右边的值赋给左边

复合赋值操作符：

*=

+=

-=

/=

%=

<<=

>>=

>>>=

num = num + 10;相当于num += 10;

声明变量

var a, b, c;

赋值

`a = (0, 1, 2, 3); //3, 只最后一项有效