JavaScript基础(一)之[乘性，加性，关系，相等，条件，赋值，逗号]操作符

红太狼 2022-05-14 23:36 201阅读 0赞

# JavaScript基础(一)之\[乘性，加性，关系，相等，条件，赋值，逗号\]操作符 #

## 乘性操作符 ##

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

### 乘法 ###

*  乘法操作符由一个星号(\*)表示，用于计算两个数值的乘积。其语法类似于C，如下面的例子所示：

var result = 34 * 56;

*  在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：  
    
    
     *  如果操作数都是数值，执行常规的乘法计算，即两个正数或者两个负数相乘的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了ECMAScript数值的表示范围，则返回`Infinity`或者`-Infinity`;
     *  如果有一个操作数是NaN，则结果是NaN；
     *  如果是Infinity与0相乘，则结果是NaN;
     *  如果是Infinity与非0数值相乘，则结果是Infinity或者是-Infinity，取决于有符号操作数的符号；
     *  如果是Infinity与Infinity相乘，则结果是Infinity；
     *  如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

### 除法 ###

*  除法操作符由一个斜线符号(/)表示，执行第二个操作数除第一个操作数的计算，如下面的例子所示：

var result = 66 / 11;

*  与乘法操作符类似，除法操作符对特殊的值也有特殊的处理规则。这些规则如下：  
    
    
     *  如果操作数都是数值，执行常规的除法计算，即两个正数或者两个负数相除的结果还是正数，而如果只有一个操作数有符号，那么结果就是负数。如果商超过了ECMAScript数值的表示范围，则返回Infinity或者-Infinity；
     *  如果有一个操作数是NaN，则结果是NaN；
     *  如果是Infinity被Infinity除，则结果是NaN；
     *  如果是零被零除，则结果是NaN；
     *  如果是非零的有限数被零除，则结果是Infinity或者-Infinity，取决于有符号操作数的符号；
     *  如果是Infinity被任何非零数值除，则结果是Infinity或者-Infinity，取决于有符号操作数的符号；
     *  如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

### 求模 ###

*  求模(余数)操作符由一个百分号(%)表示，用法如下：

var result = 26 % 5; // 等于1

*  与另外两个乘性操作符类似，求模操作符会遵循下列特殊规则来处理特殊的值：  
    
    
     *  如果操作数都是数值，执行常规的除法计算，返回除得的余数；
     *  如果被除数是无穷大值而除数是有限大的数值，则结果是NaN；
     *  如果被除数是由无限大的数值而除数是零，则结果是NaN；
     *  如果是Infinity被Infinity除，则结果是NaN；
     *  如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数；
     *  如果除数是零，则结果是零；
     *  如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

--------------------

## 加性操作符 ##

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

### 加法 ###

*  加法操作符(+)的用法如下所示：

var result = 1 + 2;

*  如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：  
    
    
     *  如果有一个操作数是NaN，则结果是NaN；
     *  如果是Infinity加Infinity，则结果是Infinity；
     *  如果是-Infinity加-Infinity，则结果是-Infinity；
     *  如果是-Infinity加Infinity，则结果是NaN；
     *  如果是+0加+0，则结果是+0；
     *  如果是-0加-0，则结果是-0；
     *  如果是+0加-0，则结果是+0；
 *  不过，如果有一个操作数是字符串，那么就要应用如下规则：  
    
    
     *  如果两个操作数都属字符串，则将第二个操作数与第一个操作数拼接起来；
     *  如果只有一个操作数是字符串，则将另一个操作数转换为字符串，然后再将两个字符串拼接起来。
 *  如果有一个操作数是对象、数值或者布尔值，则调用它们的`toString()`方法取得相应的字符串值，然后再应用前面关于字符串的规则。对于`undefined`和`null`，则分别调用String()函数并取得字符串”undefined”和”null”。
 *  下面举几个例子：

var result = 5 + 5; // 两个数值相加
    console.log(result); // 10
    var result2 = 5 + "5"; // 一个数值和一个字符串相加
    console.log(result2); // "55"

*  以上代码演示了加法操作符在两种模式下的差别。第一行代码演示了正常的情况，即5 + 5 等于 10(数值)。但是，如果将一个操作数改为字符串”5”，结果变成了”55”(字符串值)，因为第一个操作数也被转换成了”5”。
 *  忽视加法操作中的数据类型是ECMAScript编程中最常见的以一个错误。再来看一个例子：

var num1 = 5;
    var num2 = 10;
    var message = "The sum of 5 and 10 is " + (num1 + num2);
    console.log(message); // "The sum of 5 and 10 is 15"

*  在这个例子中，一对圆括号把两个数值变量括在了一起，这样就会告诉解析器先计算其结果，然后再将结果与字符串拼接起来。因此，就得到了结果”The sum of 5 and 10 is 15”。

### 减法 ###

*  减法操作符(-)是另一个极为常用的操作符，其用法如下所示：

var result = 2 - 1;

*  与加法操作符类似，ECMAScript中的减法操作符在处理各种数据类型转换时，同样需要遵循一些规则，如下所示：  
    
    
     *  如果两个操作符都是数值，则执行常规的算术减法操作并返回结果；
     *  如果有一个操作数是NaN，则结果是NaN；
     *  如果是Infinity减Infinity，则结果是NaN；
     *  如果是-Infinity减-Infinity，则结果是NaN；
     *  如果是Infinity减-Infinity，则结果是NaN；
     *  如果是-Infinity减Infinity，则结果是-Infinity；
     *  如果是+0减+0，则结果是+0；
     *  如果是+0减-0，则结果是+0；(验证的结果得出的结论，《JavaScript高级程序设计（第3版）》中错在错误)
     *  如果是-0减-0，则结果是+0；
     *  如果有一个操作数是字符串、布尔值、null或者undefined，则先在后台调用`Number()`函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是NaN，则减法的结果就是NaN；
     *  如果有一个操作数是对象，则调用对象的valueOf()方法以取得表示该对象的数值。如果得到的值是NaN，则减法的结果是NaN。如果对象没有valurOf()方法，则调用其toString()方法并将得到的字符串转换为数值。
 *  下面几个例子展示了上面的规则：

var result1 = 5 - true; // 4, 因为true被转换成了1
    var result2 = NaN - 1; // NaN
    var result3 = 5 - 3; // 2
    var result4 = 5 - ""; // 5, 因为""被转换成了0
    var result5 = 5 - "2"; // 3, 因为"2"被转换成了2
    var result6 = 5 - null; // 5, 因为null被转换成了0

--------------------

## 关系操作符 ##

*  **小于(<)**、**大于(>)**、**小于等于(<=)**和**大于等于(>=)**这几个关系操作符用于对两个值进行比较，比较的规则与我们在数学课上所学的一样。这几个操作都返回一个布尔值，如下面的例子所示:

var result1 = 5 > 3; //true
    var result2 = 5 < 3; //false

*  与ECMEScript中的其他操作符一样，当关系操作符的操作数使用了非数值时，也要进行数据转换或者完成某些奇怪的操作。以下就是相应的规则。  
    
    
     *  如果两个操作数都是数值，则执行数值比较。
     *  如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。
     *  如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。
     *  如果一个操作数是对象，则调用这个对象的`valueOf()`方法，用得到的结果按照前面的规则执行比较。如果对象没有`valueOf()`方法，则调用`toString()`方法，并用得到的结果根据前面的规则执行比较。
     *  如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
 *  在使用关系操作符比较两个字符串时，会执行一种奇怪的操作。很多人都会认为，在比较字符串值时，小于的意思是”在字母表中的位置靠前”，而大于则意味着”在字母表中的位置靠后”，但实际上完全不是那么回事。在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值。经过这么一番比较之后，再返回一个布尔值。由于大写字母的字符编码全部小于小写的字符编码，因此我们就会看到如下所示的奇怪现象:

var result = "Brick" < "alphabet"; // true

*  在这个例子中，字符串”Brick”被认为小于字符串”alphabet”。原因是字母B的字符编码为`66`而字母a的字符编码是97。如果要真正被字母表顺序比较字符串，就必须把两个操作数转换为相同的大小写形式(全部大写或者全部小写)，然后再执行比较，如下所示:

var result = "Brick".toLowerCase() < "alphabet".toLowerCase(); //fase

*  通过将两个操作数都转换为小写形式，就可以得出”alphabet”按字母表顺序排在”Brick”之前的正确判断了。
 *  另一种奇怪的现象发生在比较两个数字字符串的情况下，比如下面这个例子:

var result "23" < "3"; //true

*  确实，当比较字符串”23”是否小于”3”时，结果居然是true。这是因为两个操作数都是字符串，而字符串比较的是字符编码(“2”的字符编码是50，而”3”得字符编码是51)。不过，如果像下面例子中一样，将一个操作数改为数值，比较的结果就正常了:

var result = "23" < 3; //false

*  此时，字符串”23”会被转换成数值23，然后再与3进行比较，因此就会得到合理的结果。在比较数值和字符串时，字符串都会被转换成数值，然后再以数值方式与另一个数值比较。当然，这个规则对前面的例子是适用的。可是，如果那个字符串不能被转换成一个合理的数值呢？比如:

var result = "a" < 3; // false, 因为"a"被转换成了NaN

*  由于字母”a”不能转换成合理的数值，因此就被转换成了NaN。根据规则，任何操作数与NaN进行关系比较，结果都是false。于是，就出现了下面这个有意思的现象:

var result1 = NaN < 3; // false
    var result2 = NaN >= 3; // false

*  按照常理，如果一个值不小于另一个值，则一定是大于或者等于那个值。然而，在与NaN进行比较时，这两个比较操作的结果就都返回了false。

--------------------

## 相等操作符 ##

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

### 相等和不相等 ###

*  ECMAScript中的**相等操作符由两个等于号(==)表示**，如果两个操作符相等，则返回true。而**不相等操作符由叹号后跟等于号(!=)表示**，如果两个操作数不相等，则返回true。这两个操作符都会先转换操作数(通常称为**强制转型**)，然后再比较它们的相等性。
 *  在转换不同的数据类型时，相等和不相等操作符遵循下列基本规则：  
    
    
     *  如果有一个操作数是布尔值，则在**比较相等性之前先将其转换为数值**——false转换为0，而true转换为1；
     *  如果一个操作数是字符串，另一个操作数是数值，在**比较相等性之前先将字符串转换为数值**；
     *  如果一个操作数是对象，另一个操作数不是，则调用对象的`valueOf()`方法，用得到的基本类型值按照前面的规则进行比较；
 *  这两个操作符在进行比较时则要遵循下列规则。  
    
    
     *  `null`和`undefined`是相等的。
     *  要比较相等性之前，不能将`null`和`undefined`转换成其他任何值。
     *  如果有一个操作数是`NaN`，则相等操作符返回`false`，而不相等操作符返回true。重要提示：即使**两个操作数都是`NaN`，相等操作符也返回`false`；因为按照规则，`NaN`不等于`NaN`**。
     *  如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作数返回true；否则，返回false。
 *  下表列出了一些特殊情况及比较结果：

<table> 
 <thead> 
  <tr> 
   <th>表达式</th> 
   <th>值</th> 
   <th>表达式</th> 
   <th>值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>null == undefined</td> 
   <td>true</td> 
   <td>true == 1</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>“NaN” == NaN</td> 
   <td>false</td> 
   <td>true == 2</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>5 == NaN</td> 
   <td>false</td> 
   <td>undefined == 0</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>NaN == NaN</td> 
   <td>false</td> 
   <td>null == 0</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>NaN != NaN</td> 
   <td>true</td> 
   <td>“5” == 5</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>false == 0</td> 
   <td>true</td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### 全等和不全等 ###

*  除了在比较之前不转换操作数之外，全等和不全等操作数与相等和不相等操作符没有什么区别。全等操作数由3个等于号(===)表示，它只在两个操作数未经转换就相等的情况下返回true，如下面的例子所示：

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

*  在这个例子中，第一个比较使用的是相等操作符比较字符串”55”和数值55，结果返回了true。如前所述，这是因为字符串”55”先被转换成了数值55，然后再与另一个数值55进行比较。第二个比较使用了全等操作符以不转换数值的方式比较同样的字符串和值。在不转换的情况下，字符串当然不等于数值，因此结果就是false。
 *  不全等操作符由一个叹号后跟两个等于号(!==)表示，它在两个操作数未经转换就不相等的情况下返回true。例如：

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

*  在这个例子中，第一个比较使用了不相等操作符，而该操作符会将字符串”55”转换成55，结果就与第二个操作数(也是55)相等了。而由于这两个操作数被认为相等，因此就返回了false。第二个比较使用了不全等操作符。假如我们这样想：字符串55与数值55不相同吗？那么答案一定是：是的(true)。
 *  记住：`null == undefined`会返回true，因为它们是类似的值；但`null === undefined`会返回false，因为它们是不同类型的值。

> 由于相等和不相等操作符存在类型转换问题，而为了保持代码中数据类型的完整性，我们推荐使用全等和不全等操作符。

--------------------

## 条件操作符 ##

*  条件操作符应该算是ECMAScript中最灵活的一种操作符了，而且它遵循与Java中的条件操作符相同的语法形式，如下面的例子所示：

variable = boolean_expression ? true_value : false_value;

*  本质上，这行代码的含义就是基于对`boolean_expression`求值的结果，决定给变量variable赋什么值。如果求值结果为true，则给变量variable赋`true_value`值；如果求值结果为false，则给变量variable赋`false_value`值。再看一个例子：

var max = (num1 > num2) ? num1 : num2;

*  在这个例子中，`max`中将会保存一个最大的值。这个表达式的意思是：如果**num1大于num2**(关系表达式返回true)，则将**num1的值赋给max**；如果**num1小于或者等于num2**(关系表达式返回false)，则将**num2的值赋给max**。

--------------------

## 赋值操作符 ##

*  简单的赋值操作符由等于号(=)表示，其作用就是把右侧的值赋给左侧的变量，如下面的例子所示：

var num = 10;

*  如果在等于号(=)前面再添加乘性操作符、加性操作符或者位操作符，就可以完成复合赋值操作。这种复合操作相当于是对下面常规表达式的简写形式：

var num = 10; num = num + 10;

*  其中的第二行代码可以用一个复合赋值来代替：

var num = 10; num += 10;

*  每个主要算术操作符(以及个别的其他操作符)都有对应的复合赋值操作符。这些操作符如下所示:  
    
    
     *  乘/赋值(\*=)；
     *  除/赋值(/=)；
     *  模/赋值(%=)；
     *  加/赋值(+=)；
     *  减/赋值(-=)；
     *  左移/赋值(<<=)；
     *  有符号右移/赋值(>>=)；
     *  无符号右移/赋值(>>>=)。
 *  设计这些操作符的主要目的就是简化赋值操作。使用它们不会带来任何性能的提升。

--------------------

## 逗号操作符 ##

*  使用逗号操作符可以在一条语句中执行多个操作，如下面的例子所示：

var num1=1, num2=2, num3=3;

*  逗号操作符多用于声明多个变量；但除此之外，逗号操作符还可以用于赋值。在用于赋值时，逗号操作符总会返回表达式中的最后一项，如下面的例子所示：

var num = (5, 1, 4, 8, 0); // num的值为0

*  由于0是表达式中的最后一项，因此num的值就是0。虽然逗号的这种使用方式并不常见，但这个例子可以帮我们理解逗号的这种行为。

> JackDan Thinking