JavaScript基础语法03

JavaScirpt描述了一组用于操作数据值的操作符，包括算术操作符（如加号和减号）、位操作符、关系操作符和相等操作符。JavaScript 操作符的与众不同之处在于，它们能够适用于很多值，例如字符串、数字值、布尔值，甚至对象。不过，在应用于对象时，相应的操作符通常都会调用对象的valueOf()和（或）toString()方法，以便取得可以操作的值。

一、一元操作符

只能操作一个值的操作符叫做一元操作符。一元操作符是JavaScript 中最简单的操作符。

递增和递减操作符

递增和递减操作符直接借鉴自C，和Java类似，而且各有两个版本：前置型和后置型。顾名思义，前置型应该位于要操作的变量之前，而后置型则应该位于要操作的变量之后。
所有这4 个操作符对任何值都适用，也就是它们不仅适用于整数，还可以用于字符串、布尔值、浮点数值和对象。在应用于不同的值时，递增和递减操作符遵循下列规则。

在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减1 的操作。字符串变量变成数值变量。

在应用于一个不包含有效数字字符的字符串时，将变量的值设置为NaN。字符串变量变成数值变量。

在应用于布尔值false 时，先将其转换为0 再执行加减1 的操作。布尔值变量变成数值变量。

在应用于布尔值true 时，先将其转换为1 再执行加减1 的操作。布尔值变量变成数值变量。

在应用于浮点数值时，执行加减1 的操作。

在应用于对象时，先调用对象的valueOf()方法以取得一个可供操作的值。然后对该值应用前述规则。如果结果是NaN，则在调用toString()方法后再应用前述规则。对象变量变成数值变量。

以下示例展示了上面的一些规则：
<script>
 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
</script>

一元加和减操作符

绝大多数开发人员对一元加和减操作符都不会陌生，而且这两个JavaScript 操作符的作用与数学书上讲的完全一样。一元加操作符以一个加号（+）表示，放在数值前面，对数值不会产生任何影响，如下面的例子所示：
<script>
   var num = 25;
   num = +num; // 仍然是25
</script>
不过，在对非数值应用一元加操作符时，该操作符会像Number()转型函数一样对这个值执行转换。换句话说，布尔值false 和true 将被转换为0 和1，字符串值会被按照一组特殊的规则进行解析，而对象是先调用它们的valueOf()和（或）toString()方法，再转换得到的值。下面的例子展示了对不同数据类型应用一元加操作符的结果：
<script>
   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
</script>
一元减操作符主要用于表示负数，例如将1 转换成 -1。下面的例子演示了这个简单的转换过程：
<script>
   var num = 25;
   num = -num; // 变成了-25
</script>
在将一元减操作符应用于数值时，该值会变成负数（如上面的例子所示）。而当应用于非数值时，一元减操作符遵循与一元加操作符相同的规则，最后再将得到的数值转换为负数，如下面的例子所示：
<script>
   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
</script>

一元加和减操作符主要用于基本的算术运算，也可以像前面示例所展示的一样用于转换数据类型。

二、位操作符

操作符用于在最基本的层次上，即按内存中表示数值的位来操作数值。JavaScript 中的所有数值都以64 位格式存储，但位操作符并不直接操作64 位的值。而是先将64 位的值转换成32 位的整数，然后执行操作，最后再将结果转换回64 位。对于开发人员来说，由于64 位存储格式是透明的，因此整个过程就像是只存在32 位的整数一样。

对于有符号的整数，32 位中的前31 位用于表示整数的值。第32 位用于表示数值的符号：0 表示正数，1 表示负数。这个表示符号的位叫做符号位，符号位的值决定了其他位数值的格式。其中，正数以纯二进制格式存储，31 位中的每一位都表示2 的幂。第一位（叫做位0）表示20，第二位表示21，以此类推。没有用到的位以0 填充，即忽略不计。例如，数值18 的二进制表示是00000000000000000000000000010010，或者更简洁的10010。这是5 个有效位，这5 位本身就决定了实际的值。

负数同样以二进制码存储，但使用的格式是二进制补码。计算一个数值的二进制补码，需要经过下列3 个步骤：
(1) 求这个数值绝对值的二进制码（例如，要求 -18 的二进制补码，先求18 的二进制码）；
(2) 求二进制反码，即将0 替换为1，将1 替换为0；
(3) 得到的二进制反码加1。

在JavaScript 中，当对数值应用位操作符时，后台会发生如下转换过程：64 位的数值被转换成32位数值，然后执行位操作，最后再将32 位的结果转换回64 位数值。这样，表面上看起来就好像是在操作32 位数值，就跟在其他语言中以类似方式执行二进制操作一样。但这个转换过程也导致了一个严重的副效应，即在对特殊的NaN 和Infinity 值应用位操作时，这两个值都会被当成0 来处理。

如果对非数值应用位操作符，会先使用Number()函数将该值转换为一个数值（自动完成），然后再应用位操作。得到的结果将是一个数值。

按位非（NOT）

按位非操作符由一个波浪线（~）表示，执行按位非的结果就是返回数值的反码。按位非是JavaScript 操作符中少数几个与二进制计算有关的操作符之一。下面看一个例子：
<script>
   var num1 = 25; // 二进制00000000000000000000000000011001
   var num2 = ~num1; // 二进制11111111111111111111111111100110
   alert(num2); // -26
</script>

按位与（AND）

按位与操作符由一个和号字符（&）表示，它有两个操作符数。简而言之，按位与操作只在两个数值的对应位都是1 时才返回1，任何一位是0，结果都是0。下面看一个对25 和3 执行按位与操作的例子：
<script>
   /*
    25 = 0000 0000 0000 0000 0000 0000 0001 1001
     3 = 0000 0000 0000 0000 0000 0000 0000 0011
    ---------------------------------------------
    AND = 0000 0000 0000 0000 0000 0000 0000 0001
    */
   var result = 25 & 3;
   alert(result); //1
</script>

按位或（OR）

按位或操作符由一个竖线符号（|）表示，同样也有两个操作数。按位或操作在有一个位是1 的情况下就返回1，而只有在两个位都是0 的情况下才返回0。如果在前面按位与的例子中对25 和3 执行按位或操作，则代码如下所示：
<script>
   /*
    25 = 0000 0000 0000 0000 0000 0000 0001 1001
     3 = 0000 0000 0000 0000 0000 0000 0000 0011
    --------------------------------------------
    OR = 0000 0000 0000 0000 0000 0000 0001 1011
    */
   var result = 25 | 3;
   alert(result); //27
</script>

按位异或（XOR）

按位异或操作符由一个插入符号（^）表示，也有两个操作数。按位异或与按位或的不同之处在于，这个操作在两个数值对应位上只有一个1 时才返回1，如果对应的两位都是1 或都是0，则返回0。对25 和3 执行按位异或操作的代码如下所示：
<script>
   /*
    25 = 0000 0000 0000 0000 0000 0000 0001 1001
     3 = 0000 0000 0000 0000 0000 0000 0000 0011
    ---------------------------------------------
    XOR = 0000 0000 0000 0000 0000 0000 0001 1010
    */
   var result = 25 ^ 3;
   alert(result); //26
</script>

左移

左移操作符由两个小于号（<<）表示，这个操作符会将数值的所有位向左移动指定的位数。例如，如果将数值2（二进制码为10）向左移动5 位，结果就是64（二进制码为1000000），代码如下所示：
<script>
   var oldValue = 2; // 等于二进制的10
   var newValue = oldValue << 5; // 等于二进制的1000000，十进制的64
</script>

有符号的右移

有符号的右移操作符由两个大于号（>>）表示，这个操作符会将数值向右移动，但保留符号位（即正负号标记）。有符号的右移操作与左移操作恰好相反，即如果将64 向右移动5 位，结果将变回2：
<script>
   var oldValue = 64; // 等于二进制的1000000
   var newValue = oldValue >> 5; // 等于二进制的10 ，即十进制的2
</script>

无符号右移

无符号右移操作符由3 个大于号（>>>）表示，这个操作符会将数值的所有32 位都向右移动。对正数来说，无符号右移的结果与有符号右移相同。仍以前面有符号右移的代码为例，如果将64 无符号右移5 位，结果仍然还是2：
<script>
   var oldValue = 64; // 等于二进制的1000000
   var newValue = oldValue >>> 5; // 等于二进制的10 ，即十进制的2
   var oldValue = -64; // 等于二进制的11111111111111111111111111000000
   var newValue = oldValue >>> 5; // 等于十进制的134217726
</script>

三、布尔操作符

在一门编程语言中，布尔操作符的重要性堪比相等操作符。如果没有测试两个值关系的能力，那么诸如if...else 和循环之类的语句就不会有用武之地了。布尔操作符一共有3 个：非（NOT）、与（AND）和或（OR）。

逻辑非

逻辑非操作符由一个叹号（！）表示，可以应用于JavaScript 中的任何值。无论这个值是什么数据类型，这个操作符都会返回一个布尔值。逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。也就是说，逻辑非操作符遵循下列规则：

如果操作数是一个对象，返回false；

如果操作数是一个空字符串，返回true；

如果操作数是一个非空字符串，返回false；

如果操作数是数值0，返回true；

如果操作数是任意非0 数值（包括Infinity），返回false；

如果操作数是null，返回true；

如果操作数是NaN，返回true；

如果操作数是undefined，返回true。

下面几个例子展示了应用上述规则的结果：
<script>
   alert(!false); // true
   alert(!"blue"); // false
   alert(!0); // true
   alert(!NaN); // true
   alert(!""); // true
   alert(!12345); // false
</script>

逻辑非操作符也可以用于将一个值转换为与其对应的布尔值。而同时使用两个逻辑非操作符，实际上就会模拟Boolean()转型函数的行为。其中，第一个逻辑非操作会基于无论什么操作数返回一个布尔值，而第二个逻辑非操作则对该布尔值求反，于是就得到了这个值真正对应的布尔值。当然，最终结果与对这个值使用Boolean()函数相同，如下面的例子所示：
<script>
   alert(!!"blue"); //true
   alert(!!0); //false
   alert(!!NaN); //false
   alert(!!""); //false
   alert(!!12345); //true
</script>

逻辑与

逻辑与操作符由两个和号（&&）表示，有两个操作数。

逻辑与操作可以应用于任何类型的操作数，而不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值；此时，它遵循下列规则：

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

如果第二个操作数是对象，则只有在第一个操作数的求值结果为true 的情况下才会返回该对象；

如果两个操作数都是对象，则返回第二个操作数；

如果有一个操作数是null，则返回null；

如果有一个操作数是NaN，则返回NaN；

如果有一个操作数是undefined，则返回undefined。

逻辑或

逻辑或操作符由两个竖线符号（||）表示，有两个操作数。

与逻辑与操作相似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此时，它遵循下列规则：

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

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

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

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

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

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

四、乘性操作符

JavaScript 定义了3 个乘性操作符：乘法、除法和求模。这些操作符与Java、C 或者Perl 中的相应操作符用途类似，只不过在操作数为非数值的情况下会执行自动的类型转换。如果参与乘性计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。也就是说，空字符串将被当作0，布尔值true 将被当作1。

乘法

乘法操作符由一个星号（*）表示，用于计算两个数值的乘积。其语法类似于C，如下面的例子所示：
<script>
   var result = 34 * 56;
</script>
在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：

如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了JavaScript 数值的表示范围，则返回Infinity 或-Infinity；

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

如果是Infinity 与0 相乘，则结果是NaN；

如果是Infinity 与非0 数值相乘，则结果是Infinity 或-Infinity，取决于有符号操作数的符号；

如果是Infinity 与Infinity 相乘，则结果是Infinity；

如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

除法

除法操作符由一个斜线符号（/）表示，执行第二个操作数除第一个操作数的计算，如下面的例子所示：
<script>
   var result = 66 / 11;
</script>
与乘法操作符类似，除法操作符对特殊的值也有特殊的处理规则。这些规则如下：

如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果商超过了JavaScript 数值的表示范围，则返回Infinity 或-Infinity；

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

如果是Infinity 被Infinity 除，则结果是NaN；

如果是零被零除，则结果是NaN；

如果是非零的有限数被零除，则结果是Infinity 或-Infinity，取决于有符号操作数的符号；

如果是Infinity 被任何非零数值除，则结果是Infinity 或-Infinity，取决于有符号操作数的符号；

如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

求模

求模（余数）操作符由一个百分号（%）表示，用法如下：
<script>
   var result = 26 % 5; // 等于1
</script>
与另外两个乘性操作符类似，求模操作符会遵循下列特殊规则来处理特殊的值：

如果操作数都是数值，执行常规的除法计算，返回除得的余数；

如果被除数是无穷大值而除数是有限大的数值，则结果是NaN；

如果被除数是有限大的数值而除数是零，则结果是NaN；

如果是Infinity 被Infinity 除，则结果是NaN；

如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数；

如果被除数是零，则结果是零；

如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

五、加性操作符

加法和减法这两个加性操作符应该说是编程语言中最简单的算术操作符了。但是在JavaScript 中，这两个操作符却都有一系列的特殊行为。与乘性操作符类似，加性操作符也会在后台转换不同的数据类型。然而，对于加性操作符而言，相应的转换规则还稍微有点复杂。

加法

加法操作符（+）的用法如下所示：
<script>
   var result = 1 + 2;
</script>
如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：

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

如果是Infinity 加Infinity，则结果是Infinity；

如果是-Infinity 加 -Infinity，则结果是 -Infinity；

如果是Infinity 加-Infinity，则结果是NaN；

如果是+0 加+0，则结果是+0；

如果是 -0 加 -0，则结果是 -0；

如果是+0 加 -0，则结果是+0。

不过，如果有一个操作数是字符串，那么就要应用如下规则：

如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来；

如果只有一个操作数是字符串，则将另一个操作数转换为字符串，然后再将两个字符串拼接起来。

减法

减法操作符（-）是另一个极为常用的操作符，其用法如下所示：
<script>
   var result = 2 - 1;
</script>
与加法操作符类似，JavaScript 中的减法操作符在处理各种数据类型转换时，同样需要遵循一些特殊规则，如下所示：

如果两个操作符都是数值，则执行常规的算术减法操作并返回结果；

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

如果是Infinity 减Infinity，则结果是NaN；

如果是-Infinity 减-Infinity，则结果是NaN；

如果是Infinity 减-Infinity，则结果是Infinity；

如果是 -Infinity 减Infinity，则结果是 -Infinity；

如果是+0 减+0，则结果是+0；

如果是+0 减 -0，则结果是 -0；

如果是0 减0，则结果是+0；

如果有一个操作数是字符串、布尔值、null 或undefined，则先在后台调用Number()函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是NaN，则减法的结果就是NaN；

如果有一个操作数是对象，则调用对象的valueOf()方法以取得表示该对象的数值。如果得到的值是NaN，则减法的结果就是NaN。如果对象没有valueOf()方法，则调用其toString()方法并将得到的字符串转换为数值。

六、关系操作符

小于（<）、大于（>）、小于等于（<=）和大于等于（>=）这几个关系操作符用于对两个值进行比较，比较的规则与我们在数学课上所学的一样。这几个操作符都返回一个布尔值，如下面的例子所示：
<script>
   var result1 = 5 > 3; //true
   var result2 = 5 < 3; //false
</script>
与JavaScript 中的其他操作符一样，当关系操作符的操作数使用了非数值时，也要进行数据转换或完成某些奇怪的操作。以下就是相应的规则。

如果两个操作数都是数值，则执行数值比较。

如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。

如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。

如果一个操作数是对象，则调用这个对象的valueOf()方法，用得到的结果按照前面的规则执行比较。如果对象没有valueOf()方法，则调用toString()方法，并用得到的结果根据前面的规则执行比较。

如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。

七、相等操作符

确定两个变量是否相等是编程中的一个非常重要的操作。在比较字符串、数值和布尔值的相等性时，问题还比较简单。但在涉及到对象的比较时，问题就变得复杂了。最早的JavaScript 中的相等和不等操作符会在执行比较之前，先将对象转换成相似的类型。后来，有人提出了这种转换到底是否合理的质疑。最后，JavaScript 的解决方案就是提供两组操作符：相等和不相等——先转换再比较，全等和不全等——仅比较而不转换。

相等和不相等

JavaScript 中的相等操作符由两个等于号（==）表示，如果两个操作数相等，则返回true。而不相等操作符由叹号后跟等于号（!=）表示，如果两个操作数不相等，则返回true。这两个操作符都会先转换操作数（通常称为强制转型），然后再比较它们的相等性。

在转换不同的数据类型时，相等和不相等操作符遵循下列基本规则：

如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值——false 转换为0，而true 转换为1；

如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值；

如果一个操作数是对象，另一个操作数不是，则调用对象的valueOf()方法，用得到的基本类型值按照前面的规则进行比较；

这两个操作符在进行比较时则要遵循下列规则。

null 和undefined 是相等的。

要比较相等性之前，不能将null 和undefined 转换成其他任何值。

如果有一个操作数是NaN，则相等操作符返回false，而不相等操作符返回true。重要提示：即使两个操作数都是NaN，相等操作符也返回false；因为按照规则，NaN 不等于NaN。

如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回true；否则，返回false。

全等和不全等

除了在比较之前不转换操作数之外，全等和不全等操作符与相等和不相等操作符没有什么区别。全等操作符由3 个等于号（===）表示，它只在两个操作数未经转换就相等的情况下返回true，如下面的例子所示：
<script>
   var result1 = ("55" == 55); //true，因为转换后相等
   var result2 = ("55" === 55); //false，因为不同的数据类型不相等
</script>
不全等操作符由一个叹号后跟两个等于号（!==）表示，它在两个操作数未经转换就不相等的情况下返回true。例如：
<script>
   var result1 = ("55" != 55); //false，因为转换后相等
   var result2 = ("55" !== 55); //true，因为不同的数据类型不相等
</script>

八、条件操作符

条件操作符应该算是JavaScript 中最灵活的一种操作符了，而且它遵循与Java 中的条件操作符相同的语法形式，如下面的例子所示：
variable = boolean_expression ? true_value : false_value;
<script>
   var num1 = 10;
   var num2 = 20;
   var max = (num1 > num2) ? num1 : num2;
   alert(max);
</script>

九、赋值操作符

简单的赋值操作符由等于号（=）表示，其作用就是把右侧的值赋给左侧的变量，如下面的例子所示：
<script>
   var num = 10;
   num = num + 10;
   num += 10;
</script>
每个主要算术操作符（以及个别的其他操作符）都有对应的复合赋值操作符。这些操作符如下所示：

乘/赋值（*=）；

除/赋值（/=）；

模/赋值（%=）；

加/赋值（+=）；

减/赋值（=）；

左移/赋值（<<=）；

有符号右移/赋值（>>=）；

无符号右移/赋值（>>>=）。

十、逗号操作符

使用逗号操作符可以在一条语句中执行多个操作，如下面的例子所示：
<script>
   var num1=1, num2=2, num3=3;
</script>
逗号操作符多用于声明多个变量；但除此之外，逗号操作符还可以用于赋值。在用于赋值时，逗号操作符总会返回表达式中的最后一项，如下面的例子所示：
<script>
   //由于0 是表达式中的最后一项，因此num 的值就是0。
   //虽然逗号的这种使用方式并不常见，
   //但这个例子可以帮我们理解逗号的这种行为。
   var num = (5, 1, 4, 8, 0); // num 的值为0
   alert(num);
</script>