运算符

Posted 2021-03-10 hjy-21

算术运算符

概述

javascript 共提供10个算术运算符，用来完成基本的算术运算。

加法运算符：x + y

减法运算符： x - y

乘法运算符： x * y

除法运算符：x / y

指数运算符：x ** y

余数运算符：x % y

自增运算符：++x 或者 x++

自减运算符：--x 或者 x--

数值运算符： +x

负数值运算符：-x

 

加法运算符

JavaScript 允许非数值的相加。

true + true // 2

1 + true // 2

第一行是两个布尔值相加，第二行是数值与布尔值相加。这两种情况，布尔值都会自动转成数值，然后再相加。如果是两个字符串相加，这时加法运算符会变成连接运算符，返回一个新的字符串，将两个原字符串连接在一起。

‘a‘ + ‘bc‘ // "abc"

如果一个运算子是字符串，另一个运算子是非字符串，非字符串会转成字符串，再连接在一起。

1 + ‘a‘ // "1a"

false + ‘a‘ // "falsea"

加法运算符是在运行时决定，到底是执行相加，还是执行连接。也就是说，运算子的不同，导致了不同的语法行为，这种现象称为“重载”（overload）。由于加法运算符存在重载，可能执行两种运算，使用的时候必须很小心。除了加法运算符，其他算术运算符（比如减法、除法和乘法）都不会发生重载。它们的规则是：所有运算子一律转为数值，再进行相应的数学运算。

‘3‘ + 4 + 5 // "345"

3 + 4 + ‘5‘ // "75"

由于从左到右的运算次序，字符串的位置不同会导致不同的结果。

 

对象的相加

如果运算子是对象，必须先转成原始类型的值，然后再相加。

var obj = { p: 1 };

obj + 2 // "[object Object]2"

上面代码中，对象obj转成原始类型的值是[object Object]，再加2就得到了上面的结果。

对象转成原始类型的值，规则如下。

首先，自动调用对象的valueOf方法。一般来说，对象的valueOf方法总是返回对象自身，这时再自动调用对象的toString方法，将其转为字符串。

var obj = { p: 1 };

obj.valueOf().toString() // "[object Object]"

;

余数运算符

余数运算符（%）返回前一个运算子被后一个运算子除，所得的余数。运算结果的正负号由第一个运算子的正负号决定。

 

自增和自减运算符

自增和自减运算符，是一元运算符，只需要一个运算子。它们的作用是将运算子首先转为数值，然后加上1或者减去1。它们会修改原始变量。

运算之后，变量的值发生变化，这种效应叫做运算的副作用（side effect）。自增和自减运算符是仅有的两个具有副作用的运算符，其他运算符都不会改变变量的值。

符号在前先运算再返回运算后的值，符号在后运算前面的在进行自增或自减

 

数值运算符，负数值运算符

数值运算符（+）同样使用加号，但它是一元运算符（只需要一个操作数），而加法运算符是二元运算符（需要两个操作数）。

数值运算符的作用在于可以将任何值转为数值（与Number函数的作用相同）。

+true // 1

+[] // 0

+{} // NaN

上面代码表示，非数值经过数值运算符以后，都变成了数值（最后一行NaN也是数值）。

负数值运算符（-），也同样具有将一个值转为数值的功能，只不过得到的值正负相反。连用两个负数值运算符，等同于数值运算符。

数值运算符号和负数值运算符，都会返回一个新的值，而不会改变原始变量的值。

 

指数运算符

指数运算符（**）完成指数运算，前一个运算子是底数，后一个运算子是指数。

2 ** 4 // 16

指数运算符是右结合，而不是左结合。即多个指数运算符连用时，先进行最右边的计算。

// 相当于 2 ** (3 ** 2)

2 ** 3 ** 2

// 512

上面代码中，由于指数运算符是右结合，所以先计算第二个指数运算符，而不是第一个。

 

赋值运算符

赋值运算符（Assignment Operators）用于给变量赋值。

最常见的赋值运算符，就是等号（=）。

赋值运算符可以与其他运算符结合，形成变体。

 

比较运算符

比较运算符用于比较两个值的大小，然后返回一个布尔值，表示是否满足指定的条件。比较运算符可以比较各种类型的值，不仅仅是数值。

JavaScript 一共提供了8个比较运算符。

> 大于运算符

< 小于运算符

<= 小于或等于运算符

>= 大于或等于运算符

== 相等运算符

=== 严格相等运算符

!= 不相等运算符

!== 严格不相等运算符

这八个比较运算符分成两类：相等比较和非相等比较。两者的规则不一样，对于非相等的比较，算法是先看两个运算子是否都是字符串，如果是的，就按照字典顺序比较（实际上是比较 Unicode 码点）；否则，将两个运算子都转成数值，再比较数值的大小。

非相等运算符：字符串的比较

字符串按照字典顺序进行比较。

‘cat‘ > ‘Cat‘ // true‘

上面代码中，小写的c的 Unicode 码点（99）大于大写的C的 Unicode 码点（67），所以返回true。

由于所有字符都有 Unicode 码点，因此汉字也可以比较。

‘大‘ > ‘小‘ // false

上面代码中，“大”的 Unicode 码点是22823，“小”是23567，因此返回false。

 

非相等运算符：非字符串的比较

如果两个运算子之中，至少有一个不是字符串，需要分成以下两种情况。

（1）原始类型值

如果两个运算子都是原始类型的值，则是先转成数值再比较。

5 > ‘4‘ // true

// 等同于 5 > Number(‘4‘)

2 > true // true

// 等同于 2 > Number(true)

// 即 2 > 1

字符串和布尔值都会先转成数值，再进行比较。

这里需要注意与NaN的比较。任何值（包括NaN本身）与NaN比较，返回的都是false。

（2）对象

如果运算子是对象，会转为原始类型的值，再进行比较。

对象转换成原始类型的值，算法是先调用valueOf方法；如果返回的还是对象，再接着调用toString方法。

var x = [2];

x > ‘11‘ // true

// 等同于 [2].valueOf().toString() > ‘11‘

// 即 ‘2‘ > ‘11‘

 

严格相等运算符

JavaScript 提供两种相等运算符：==和===。

区别是相等运算符（==）比较两个值是否相等，严格相等运算符（===）比较它们是否为“同一个值”。如果两个值不是同一类型，严格相等运算符（===）直接返回false，而相等运算符（==）会将它们转换成同一个类型，再用严格相等运算符进行比较。

（1）不同类型的值

如果两个值的类型不同，直接返回false。

1 === "1" // false

true === "true" // false

（2）同一类的原始类型值

同一类型的原始类型的值（数值、字符串、布尔值）比较时，值相同就返回true，值不同就返回false。

1 === 0x1 // true

上面代码比较十进制的1与十六进制的1，因为类型和值都相同，返回true。

NaN与任何值都不相等（包括自身）。另外，正0等于负0。

（3）复合类型值

两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址。

{} === {} // false

[] === [] // false

var v1 = {};

var v2 = v1;

v1 === v2 // true

对于两个对象的比较，严格相等运算符比较的是地址，而大于或小于运算符比较的是值。

（4）undefined 和 null

undefined和null与自身严格相等。

undefined === undefined // true

null === null // true

由于变量声明后默认值是undefined，因此两个只声明未赋值的变量是相等的严格相等运算符有一个对应的“严格不相等运算符”（!==），它的算法就是先求严格相等运算符的结果，然后返回相反值。

 

相等运算符

相等运算符用来比较相同类型的数据时，与严格相等运算符完全一样。

1 == 1.0

// 等同于

1 === 1.0

比较不同类型的数据时，相等运算符会先将数据进行类型转换，然后再用严格相等运算符比较。下面分成四种情况，讨论不同类型的值互相比较的规则。

（1）原始类型值

原始类型的值会转换成数值再进行比较。

1 == true // true

// 等同于 1 === Number(true)

‘   123  ‘ == 123 // true

// 因为字符串转为数字时，省略前置和后置的空格，上面代码将字符串和布尔值都转为数值，然后再进行比较。

（2）对象与原始类型值比较

对象（这里指广义的对象，包括数组和函数）与原始类型的值比较时，对象转换成原始类型的值，再进行比较。

// 对象与数值比较时，对象转为数值

[1] == 1 // true

// 等同于 Number([1]) == 1

（3）undefined 和 null

undefined和null与其他类型的值比较时，结果都为false，它们互相比较时结果为true。

false == null // false

false == undefined // false

undefined == null // true