ECMAScript中的操作符

一元操作符

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

1. 递增和递减。递增和递减操作符借鉴自C，而且有两个版本：前置型和后置型

   1. 前置型：操作符位于要操作的变量之前。执行前置型递增和递减操作时，变量的值都是在语句被求值以前改变的

      var age = 29;
      var anotherAge = --age + 2
      console.log(age) // 28
      console.log(anotherAge) // 30
      

   2. 后置型：操作符位于要操作的变量之后。后置型递增和递减操作是在包含它们的语句被求值之后才执行的

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

   以上4个操作符对任何值都适用，即可以用于字符串、布尔值、浮点数值和对象。遵循下列规则：

   • 在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量
   • 在应用于一个不包含有数字字符的字符串时，将变量的值设置为NaN。字符串变量变成数值变量
   • 在应用于布尔值false时，先将其转换为0再执行加减1的操作。布尔值变量变成数值变量
   • 在应用于布尔值true时，先将其转换为0再执行加减1的操作。布尔值变量变成数值变量
   • 在应用于浮点数值时，执行加减1的操作
   • 在应用于对象时，先调用对象的valueOf()方法以取得一个可供操作的值，然后对该值应用上述规则。如果是NaN，则调用toString()方法后再应用上述规则。对象变量变成数值变量

   上述规则验证：

   var s1 = "2";
   var s2 = "z";
   var b = false;
   var f = 1.1;
   var o = {
       valueOf: function () {
           return -1
       }
   }
   console.log(s1++); // 2
   console.log(s1); // 3
   console.log(s2++); // NaN
   console.log(s2); // NaN
   console.log(b++); // 0
   console.log(b); // 1
   console.log(f--); // 1.1
   console.log(f); // 0.1000000000000009
   console.log(o--); // -1
   console.log(o); // -2
   

2. 一元加和减操作符

   一元加和减操作符主要用于基本的算术运算，也可以用于转换数据类型，即在对非数值应用一元操作符时，该操作符会像Number()转型函数一样对这个值执行转换。布尔值false和true将被转换为0和1，字符串值会被按照一组特殊的规则进行解析，对象是先调用它们的valueOf()或toString()方法，再转换得到的值。以一元加操作符为例：

   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
   s2 = +s2
   s3 = +s3
   b = +b
   f = +f
   o = +o
   console.log(s1) // 1
   console.log(s2) // 1.1
   console.log(s3) // NaN
   console.log(b) // 0
   console.log(f) // 1.1
   console.log(o) // -1
   

布尔操作符

布尔操作符一共有3个：非（NOT）、与（AND）和或（OR）

1. 逻辑非。由一个英文叹号(!)表示，可以用于ECMAScript中的任何值。无论操作数是个什么数据类型，这个操作符都会返回一个布尔值。逻辑非操作符首先会将它的操作数转换为一个布尔值，然后对其求反。遵循一下规则

   • 如果操作数是一个对象，返回false
   • 如果操作数是一个空字符串，返回true
   • 如果操作数是一个非空字符串，返回false
   • 如果操作数是数值0，返回true
   • 如果操作数是任意非0数值（包括Infinity)，返回false
   • 如果操作数是null，返回true
   • 如果操作数是NaN，返回true
   • 如果操作数是undefined，返回true

   console.log(!false); // true
   console.log(!"blue"); // false
   console.log(!""); // true
   console.log(!0); // true
   console.log(!undefined); // true
   console.log(!null); // true
   console.log(!NaN); // true
   console.log(!12345); false
   

2. 逻辑与。操作符由两个和号（&&）表示，有两个操作数。逻辑与操作可以应用与任何类型的操作数，而不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值；此时，它遵循以下规则：

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

   逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值

3. 逻辑或。操作符由两个竖线符号(||)表示，有两个操作数。与逻辑与操作相似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此时，它遵循以下规则：

   • 如果第一个操作数是对象，则返回第一个操作数
   • 如果第一个操作数的求值结果为false，则返回第二个操作数
   • 如果两个操作数都是对象，则返回第一个操作数
   • 如果两个操作数都是null，则返回null
   • 如果两个操作数都是NaN，则返回NaN
   • 如果两个操作数都是undefined，则返回undefined

   与逻辑与操作符相似，逻辑或操作符也是短路操作。也就是说，如果第一个操作数的求值结果为true，就不会对第二个操作数求值了

乘性操作符

ECMAScript定义了3个乘性操作符：乘法、除法和求模。如果参与乘性计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值，如：空字符串将被当作0，布尔值true将被当作1

1. 乘法。操作符由一个星号(*)表示，用于计算两个数值的乘积。在处理特殊值情况下，乘法操作符遵循下列特殊的规则：
   • 如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数，而如果只有一个操作数有符号那么结果就是负数。如果乘积超过了ECMAScript数值的表示范围，则返回Infinity或-Infinity
   • 如果有一个操作数是NaN，则结果是NaN
   • 如果是Infinity与0相乘，则结果是NaN
   • 如果是Infinity与非0数值相乘，则结果是Infinity或-Infinity，取决于有符号操作数的符号
   • 如果是Infinity与Infinity相乘，则结果是Infinity
   • 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后在应用上面的规则
2. 除法。操作符由一个斜线符号(/)表示，执行第二个操作数除第一个操作数的计算。遵循一下规则：
   • 如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除结果还是正数；如果只有一个操作数有符号，那么结果就是负数。如果超过了ECMAScript数值的表示范围，则返回Infinity或-Infinity
   • 如果有一个操作数是NaN，则结果是NaN
   • 如果是Infinity被Infinity除，则结果是NaN
   • 如果是0被0除，则结果是NaN
   • 如果是非零的有限数被零除，则结果是Infinity或-Infinity，取决于有符号操作数的符号
   • 如果是Infinity被任何非零数值除，则结果是Infinity或-Infinity，取决于有符号操作数的符号
   • 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则
3. 求模（余数）。操作符由一个百分号(%)表示。遵循以下规则：
   • 如果操作数都是数值，执行常规的除法计算，返回除得的余数
   • 如果被除数是无穷大值而除数是有限大的数值，则结果是NaN
   • 如果被除数是有限大的数值而除数是零，则结果是NaN
   • 如果是Infinity被Infinity除，则结果是NaN
   • 如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数
   • 如果被除数是零，则结果是零
   • 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后在应用上面规则

加性操作符

与乘性操作符类似，加性操作符也会在后台转换不同的数据类型。

1. 加法。加法操作符由加号（+）表示。如果两个操作数都是数值，执行常规的加法计算，然后根据下列规则返回结果：

   • 如果有一个操作数是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"

2. 减法。减法操作符由减号（-）表示，与加法操作符类似，遵循以下规则：

   • 如果两个操作符都是数值，则执行常规的算术减法操作并返回结果
   • 如果有一个操作数是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()方法并将得到的字符串转换为数值

   var result1 = 5 - true
   var result2 = NaN - 1
   var result3 = 5 - 3
   var result4 = 5 - ""
   var result5 = 5 - "2"
   var result6 = 5 - null
   console.log(result1) // 4, true被转换为1
   console.log(result2) // NaN
   console.log(result3) // 2
   console.log(result4) // 5, 空字符串被转换为0
   console.log(result5) // 3，字符串2被转换为数字2
   console.log(result6) // 5，因为null被转换为了0
   

关系操作符

关系操作符有小于（<）、大于（>）、小于等于（<=）和大于等于（>=）四个关系比较。当关系操作符的操作数使用了非数值时，也要进行数据转换或完成某些奇怪的操作。相应规则如下：

• 如果两个操作数都是数值，则执行数值比较
• 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值
• 如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较
• 如果一个操作数是对象，则调用这个对象的valueOf()方法，用得到的结果按照前面的的规则进行比较。如果对象没有valueOf()方法，则调用toString()方法，并用得到的结果根据前面的规则执行比较
• 如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较

在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值。经过这么一番比较之后，再返回一个布尔值。大写字母的字符编码小于小写字母的字符编码。

相等操作符

两组操作符：相等和不相等——先转换再比较；全等和不全等——仅比较而不转换

1. 相等和不相等。相等操作符由两个等于号（==）表示，如果两个操作数相等，则返回true；不相等操作符由叹号后跟等于号（!=）表示，如果两个操作数不相等，则返回true。这两个操作符都会先转换操作数（通常称为强制转型），然后再比较它们的相等性。在转换不同数据类型时，遵循以下基本规则：

   • 如果一个操作数是布尔值，则在比较相等性之前先将其转换为数值——false转换为0，true转换为1
   • 如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值
   • 如果一个操作数是对象，另一个操作数不是，则调用对象的valueOf()方法，用得到的基本类型值按照前面的规则进行比较

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

   • null和undefined事相等的
   • 比较相等性之前，不能将null和undefined转换成其他任何值
   • 如果有一个操作数是NaN，则相等操作符返回false，而不相等操作符返回true。即使两个操作数都是NaN，则相等操作符也返回false；因为按照规则，NaN不等于NaN
   • 如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回true；否则，返回false

2. 全等和不全等。全等操作符由3个等于号（===）表示，它只在两个操作数未经转换就相等的情况下返回true。不全等操作符有一个叹号后跟两个等于号（!==）表示，它在两个操作数未经转换就不相等的情况下返回true。

   var result1 = ("55" == 55)
   var result2 = ("55" === 55)
   var result3 = ("55" != 55)
   var result4 = ("55" !== 55)
   console.log(result1) // true
   console.log(result2) // false
   console.log(result3) // false
   console.log(result4) // true
   

条件操作符

语法：var max = (num1 > num2) ? num1 : num2

以上例子中，max中将会保存一个最大的值，表达式的意思是：如果num1大于num2（关系表达式返回true），则将num1的值赋给max；如果num1小于或等于num2（关系表达式返回false），则将num2的值赋给max

赋值操作符

赋值操作符由等于号（=）表示，其作用就是把右侧的值赋给左侧的变量。如果在等号前面再添加乘性操作符、加性操作符或位操作符，就可以完成复合赋值操作。每个主要的算术操作符（以及个别的其他操作符）都有对应的复合赋值操作符。这些操作符如下所示：

• 乘/赋值——*=
• 除/赋值——/=
• 模/赋值——%=
• 加/赋值——+=
• 减/赋值——-=
• 左移/赋值——<<=
• 有符号右移/赋值——>>=
• 无符号右移/赋值——>>>=

逗号操作符

逗号操作符可以在一条语句中执行多个操作，如：var num1=1, num2=2, num3=3;。

逗号操作符还可以用于赋值，在用于赋值时，逗号操作符总会返回表达式中的最后一项。如：var num= (5, 6, 1, 4, 7, 0); // num值为0