JavaScript 算数运算符

算数运算符使用数值（字面量或者变量）作为操作数，并且返回一个单个数值。

标准运算符是加法（+），减法（-），乘法（*），除法（/）

ECMAScript操作符的与众不同之处在于，它们能够适应很多值，例如字符串、数字、布尔值，甚至是对象。

但是，在应用于对象时，相应的操作符通常都会调用对象的 valueOf() 或是 toString() 方法，以便获取可以操作的值。

 加性操作符

---

 一、加法（+）

加法可以实现数值的加减 ，以及字符串拼接

语法：

x +  y

实例：

1、（Number + Number ）数值类型相加

1+1 // 2

2、（Boolean + Number） 布尔值与数值相加，布尔类型转换为数值

　　true运算时等同于 1，false 运算的时候相当于 0

true + 1  // 2

3、（Boolean + Boolean）布尔类型与布尔类型相加，布尔类型转换为数值

false + false;   //0
true + true;   // 2
false + true;   // 1

 4、（Number + String）数值与字符串类型的相加，字符串拼串

'No' + 1   // 'No1'

 5、（String + String）字符串类型与字符串类型相加 ，字符串拼串

'say' + 'hallo'      // "sayhallo"

6、（String + Boolean） 字符串类型与布尔类型相加，字符串拼串

'result = '+true    //"result = true"

两个操作符都是数值，执行常规加法计算，然后根据下列规则返回结果：

1、如果有一个操作数是 NaN，则结果是 NaN;

2、如果是 Infinity 加 Infinity ，则结果是 Infinity;

3、如果是 -Infinity 加  -Infinity，则结果是 -Infinity;

4、如果是 Infinity 加 -Infinity，则结果是 NaN;

5、如果是 +0 加 -0，则结果是 +0;

6、如果是 -0 加 -0，则结果是 -0;

7、如果是 +0 加 +0，则结果是 +0;

但是当有一个操作符号是字符串的时候，就要应用如下规则：

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

　　2、如果只有一个操作符是字符串，则将另一个操作符转换为字符串;

如果有一个操作数是对象、数值、或是布尔值，则调用它们的 toString() 方法取得相应的字符串值，然后再应用前面的关于字符串的规则。

对于 undefined 和 null，分别调用 String() 函数取得字符串 'undefined' 和 'null' 。

二、减法（-）

使两个操作符号相减，求其差值。

语法：

x - y

实例：

按照普通减法运算的规则计算。

数值类型的值减去字符串类型的数字，得到的结果是数值类型的值。

true 转换为 1，false 转换为 0;

''转换为 0，‘2’ 转换为 2，null 转换为 0;

9 - 2    // 7
2 - 9    // -7
9 - '2'    // 7
'ww'-7     //NaN

 减法操作符在处理各种数据类型转换的时候，也需要遵循一些特殊规则：

　　1、如果有一个操作数是 NaN，则结果是 NaN;

　　2、如果是 Infinity 减 Infinity ，则结果是 NaN;

　　3、如果是 -Infinity 减  -Infinity，则结果是 NaN;

　　4、如果是 Infinity 减 -Infinity，则结果是 Infinity;

　　5、如果是 -Infinity 减 Infinity，则结果是 -Infinity;

　　6、如果是 -0 减去 -0，则结果是 +0;

　　7、如果是 +0 减 +0，则结果是 +0;

　　8、如果是 -0 减 +0，则结果是 -0;

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

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

乘性操作符

---

 一、除法（/）

除法运算的结果是两个操作数的商，左面的操作数是被除数，右面的操作数是除数。

语法：

x / y

实例：

1、JS 中 1除以2 得到的是 0.5

1 / 2         //在Javscript 中返回的是 0.5
1 / 2         //在 Java中返回的是 0
//不需要数字是明确的浮点数

 2、数字是浮点数

0作为除数的时候，所得结果为 infinity（无穷的）

1.0 / 2.0    //在 JS 和 Java 中都返回 0.5

2 / 0      // 在 JS 中返回 Infinity
2.0 / 0.0    //返回 Infinity
2.0 / 0.0    // 在JS中返回 - infinity
0 / 0     //  NaN

除法操作符对特殊值也有特殊的处理规则，规则如下：

　　1、如果操作数都是数值，执行常规的除法计算，即同号得正，异号得负。如果商超过了 ECMAScript 数值的表示范围，则返回 Infinity 或是 -Infinity

　　2、如果有一个操作数是 NaN，则结果是 NaN;

　　3、如果是 Infinity 被 Infinity除，则结果是 NaN;

　　4、如果是 0 被 0 除，则结果是 NaN;

　　5、如果是非0的有限数被 0 除，则结果是 Infinity 或 -infinity，取决于有符号操作数的符号;

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

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

二、乘法（*）

乘法运算符用于计算两个数值的乘积。

语法：

x * y

实例：

1、按照普通乘法运算规则，同号得正。

3 * 3  // 9
3 * -3  // -9
-3 * -3  // 9
//同号得正，异号得负一元操作符

2、  infinity (无穷) 乘以 0 得 NaN；infinity 乘以 infinity 得 infinity

Infinity * 3    // Infinity
Infinity * Infinity   //Infinity
Infinity * -Infinity    //-Infinity

3、字符串类型与数字类型相乘 得 NaN

"ss" * 3   // NaN
'11' * 3    // 33

4、布尔值会转换成数值再进行运算

true * 3  // 3
false * 3   // 0
false * true   // 0

 在处理特殊值的时候，乘法操作符遵行以下特殊规则：

　　1、如果操作数都数值，执行常规的乘法计算，即同号得正，异号得负。如果乘积超过了ECMAScript  数值的表示范围，则返回 Infinity 或是 -Infinity;

　　2、如果有一个操作符是 NaN，则结果是 NaN;

　　3、如果是 Infinity 与 0 相乘，则结果是 NaN;

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

　　5、如果是 Infinity 与 Infinity 相乘 ，则结果是 Infinity;

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

三、求余（%）

求余运算符返回第一个操作数对第二个操作数的模，即 var1 对 var2 取模，其中 var1 和 var2 是变量。取模功能就是 var1 除以 var 2 的整型余数。

语法：

var 1 % var 2

实例：

1、负数模以正数得 0

1 % 4       // 1
1 % 0       // NaN
1 % 0.5     // 0

2、非数字（NaN）模以 数字得 NaN

NaN % 3    // NaN
6%3     // 2
2 % null     // NaN
-2 % 3     // -2
4.4 % 2    // 0.2

求模（求余）操作符由一个百分号（%）表示，遵循以下的规则来处理特殊的值：

　　1、如果两个操作符都是数值，执行常规的除法计算，返回除得的余数

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

　　3、如果被除数是有限大的数值，而除数是 0 ，则结果是 NaN

　　4、如果是 Infinity 被 Infinity 除，则结果是 NaN

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

　　6、如果被除数是 0 ，则结果是 0

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

四、幂（ ** ）

幂运算符返回第一个操作符作底数，第二个操作数作为指数的乘方。

即 var1^var2 ，其中 var1 和 var2 是其两个`操作符。

幂运算是右结合的。a ** b ** c 等同于 a ** (b ** c)。

语法：

var 1 ** var2

 注释：

包括 PHP 或是 Python 等大多数语言中，都包含幂运算符 （一般来说符号是 ^ 或是 ** ）。

这些语言中的幂运算符有着比其他单目元算符（一元运算符 + / -）更高的优先级。

但是，在 Bash 中， ** 运算符被设计为比单目运算符的运算符运算符的优先级更低。

在最新的 JavaScript 中，禁止使用带有歧义的幂运算表达式，例如，底数前面可不可以紧跟一元运算符（+/-/~/!/delete/void/typeof）

实例：

-2 ** 2
//在Bash 中等于 4，在其他的语言中一般等于 -4
//在 JavaScript 中报错，因为会产生歧义
//不带括号的一元表达式不能出现在'**'的左侧 
//SyntaxError: unparenthesized unary expression can't appear on the left-hand side of '**'

-(2 ** 2)
// 使用圆括号就能够很清晰地表现出作者的意图，不会产生歧义，报错 

 

2 ** 3 

        即 2 的 3 次方

3 ** 2 

        即 3 的 2 次方

10 ** -1

        即 10 的 -1 次方

2  ** 3 ** 2

        即为 2 的 3^2次方 的次方（2^9 = 512），因为幂运算符遵循右结合规则

2 ** (3 ** 2)

        等价于 2 ^ 9 = 512

(2 ** 3) ** 2  

        等价于 （2^3）^ 2 = 8^2 = 64

2 ** 3 // 8
3 ** 2 // 9
3 ** 2.5 // 15.588457268119896
10 ** -1 // 0.1
NaN ** 2 // NaN

2 ** 3 ** 2 // 512
2 ** (3 ** 2) // 512
(2 ** 3) ** 2 // 64

一元操作符

---

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

前置型应该位于要进行操作的变量之前;

后置型应该位于要进行操作的变量之后;

一、递增（++）和递减（ -- ）

递增操作符实现的效果是为其操作数增加 1，并且返回一个数值。

递减操作符号将其操作数减去 1 ，并且返回一个数值。

如果后置（postfix）使用，就会在递增（减）之前返回数值（a++ / a--）

如果前置（prefix）使用，将会在递增（减）后返回数值（++a / --a）

语法：

a++ 或者 ++a
a--  或者 --a

 这是个操作符对任何值都适用，也就是它们不仅仅适用于整数，还可以用于字符串、布尔值、浮点数值和对象。在应用于不同的值时，递增和递减操作符遵行以下规则。

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

　　2、在应用于一个不包含有效数字字符的字符串时，将变量的值转换成 NaN，字符串变量变成数值变量。

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

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

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

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

后置型递增和递减操作符的语法不变，只不过需要放在变量之后而不是前面。后置与前置之间有一个重要的区别：递增和递减操作是在包含他们的语句中被裘值之后才执行的。

• num++  等价于  num + 1
• ++num  等价于  num = mun + 1

执行前置递增 和 递减操作的时候，变量的值都是在语句被求值之前被改变的（在计算机科学领域，这种情况通常被称之为副效应）

实例：

前置递减：

var num1 = 2;
var num2 = 30;
var num3 = --num1 + num2;   //等于 31
var num4 = num1 = num2;     //等于 31

在这里 num3 之所以等于 31，是因为 num1 先减去了 1 才与 num2 相加。

而变量 num4 也等于 21 是因为相应的加法操作使用了 num1 减去 1之后的值。

后置递减：

var num1 = 2;
var num2 = 30;
var num3 = num1-- + num2;   //等于 32
var num4 = num1 = num2;     //等于 31

在计算的时候 num3 使用了 num1 的原始值 2完成了加法计算，

而 num4 则使用了递减后的值 1;

二、一元加号（+）

一元加操作符使用一个加号(+)表示，在数值前面不会对数值产生任何影响。

语法：

 +x

实例：

但是在对非数值应用一元加操作符号  ，该运算符会像 Number() 转型函数一样对这个值进行转换。

布尔值 true 和 false 会转换为 1和 0；字符串值会被按照一组特殊的规则解析，而对象是先调用它们的 valueOf()  或是 toString()方法，在转换它们的到的值。

　　尽管一元负号也能转换非数值类型，但是一元正号是转换其他对象到数值的最快方法，也是最推荐的做法，因为它不会对数值执行多余的操作。

　　可以将字符串转换为整数个浮点数形式，也可以转换为非字符串值 true、false、null。小数和十六进制格式字符串也可以转换为数值。负数形式字符串也可以转换为数值（对十六进制不适用）。如果它不能解析一个值，则计算结果为 NaN。

+ '02';     // 值变成数值 2
+ '2.1'     //值变成数值 2.1
+ 'z'        //值变成  NaN
+ true     //值变成数值  1
+ 2.1       //值变成数值  2.1

var a = {valueOf:function() {return -1;}}
a = +a;
 // 值变成数值  -1

三、一元减号（-）

一元符号运算符位于操作数前面，并转换操作数的符号。

一元减操作符主要用于表示负数，例如将 1转换为 -1。

语法：

-a

实例：

在将一元减操作符应用于数值的时候，该值会转换为负数。但是当应用于非数值的时候，一元减操作符遵循一元加操作符相同的规则，最后再将得到的数值转换为负值。

- '02';     // 值变成数值 -2
- '2.1'     //值变成数值 -2.1
- 'z'        //值变成  NaN
- true     //值变成数值  -1
- 2.1       //值变成数值  -2.1

var a = {valueOf:function() {return -1;}}
a = - a;
 // 值变成数值  1

---

参考资料：

《JavaScript 高级程序设计》

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators