javaScriptES5运算符

运算符概述

javaScript共提供10个算术运算符，用来完成基本得算术运算

• 加法运算符：x + y

• 减法运算符： x - y

• 乘法运算符： x * y

• 除法运算符：x / y

• 指数运算符：x ** y

• 余数运算符：x % y

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

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

• 数值运算符： +x

• 负数值运算符：-x

加法运算符

加法运算符 ( + ) 是最常见的运算符，用来求两个数值的和。

1 +1//2
true + true //2
1+ true //2

布尔值会自动转换为数值，然后相加。

'a'+'bc' //'abc'
1+'a' //'1a'
false +'a'//false

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

'3'+4+5 //'345'
3+4+'5' //'75'

加法运算符时在运行时决定，到底是相加还是相连。按照从左到右的顺序，没有字符串，数值就相加，遇到字符串就相连，后面数值都是相连。

对象相加

会先将对象转换为原始值类型，再相加。

let obj={a:1}
obj + 2 //"[object Object]2"

对象转换为原始值类型 1.先用自身方法返回自身valueOf

2.再调用对象身上的toString 转换为字符串。

let obj = { a : 1}
obj.valueOf() //"[object Object]"
obj.valueOf().toString()//"[object Object]2"

toString()方法 将目标转换为字符串

和valueOf方法 总是返回对象自身

如果运算子是一个Date对象的实例，那么会优先执行toString方法其他对象是先执行valueOf方法

let obj = new Date();
obj.valueOf = function () { return 1 };
obj.toString = function () { return 'hello' };

obj + 2 // "hello2"

自增和自减运算符

自增和自减 都会改变原运算子的值

let i=0
++i //1 
--i// 0

自增和自减运算符有一个需要注意的地方，就是放在变量之后，会先返回变量操作前的值，再进行自增/自减操作；放在变量之前，会先进行自增/自减操作，再返回变量操作后的值。

let j=0
j++//0 
j--//0

比较运算符

javaScript 提供8个比较运算符

• > 大于运算符

• < 小于运算符

• <= 小于或等于运算符

• >= 大于或等于运算符

• == 相等运算符

• === 严格相等运算符

• != 不相等运算符

• !== 严格不相等运算符

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

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

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

'cat' > 'dog' //false
'cat' > 'catalog' //false

javaScript引擎内部首先比较首字母的 Unicode码点。如果相等再比较第二个字符的Unicode码点。

'cat' > 'Cat' //true
'大 ' > '小' //false
// '大' 码点 22823 
// '小' 码点 23567 

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

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

1)如果两个运算子都为原始类型的值，则先转换数值再比较。

5 > '4' // true
// 等同于 5 > Number('4')
// 即 5 > 4

true > false // true
// 等同于 Number(true) > Number(false)
// 即 1 > 0

2 > true // true
// 等同于 2 > Number(true)
// 即 2 > 1

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

let x = [2];
x > '11' // true
// 等同于 [2].valueOf().toString() > '11'
// 即 '2' > '11'

x.valueOf = function () { return '1' };
x > '11' // false
// 等同于 (function () { return '1' })() > '11'
// 即 '1' > '11'

//两个对象之间的比较

[2] > [1] // true
// 等同于 [2].valueOf().toString() > [1].valueOf().toString()
// 即 '2' > '1'

[2] > [11] // true
// 等同于 [2].valueOf().toString() > [11].valueOf().toString()
// 即 '2' > '11'

{ x: 2 } >= { x: 1 } // true
// 等同于 ({ x: 2 }).valueOf().toString() >= ({ x: 1 }).valueOf().toString()
// 即 '[object Object]' >= '[object Object]'

严格相等运算符

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

== 是值相等，=== 值和类型都相等。

5 == '5' //true
5 === '5' //false

数组丶对象丶函数的比较。则是比较内存地址

[] === [] //false
{} === {} //false
(function(){} === function(){}) //false

如果引用两个变量指向同一个地址 则相等
let obj1={}
let obj2=obj1
obj2 ===obj1 //true

undefined和unll 与自身严格相等 NaN不等于任何值包括自己

NaN ===NaN //false
undefined ===undefined  //true
null === null //true

相等运算符

比较不同类型的数据时，相等运算符会先将数据进行类型转换，然后再用严格相等运算符比较。

1)原始类型值

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

0 == false // true
// 等同于 0 === Number(false)

2 == true // false
// 等同于 2 === Number(true)

2 == false // false
// 等同于 2 === Number(false)

'true' == true // false
// 等同于 Number('true') === Number(true)
// 等同于 NaN === 1

'' == 0 // true
// 等同于 Number('') === 0
// 等同于 0 === 0

2)对象与原始类型值比较

// 数组与数值的比较
[1] == 1 // true

// 数组与字符串的比较
[1] == '1' // true
[1, 2] == '1,2' // true

// 对象与布尔值的比较
[1] == true // true
[2] == true // false

JavaScript 引擎会先对数组[1]调用数组的valueOf()方法，由于返回的还是一个数组，所以会接着调用数组的toString()方法，得到字符串形式。

3）undefined和null

undefined == undefined // true
null == null // true
undefined == null // true

false == null // false
false == undefined // false

0 == null // false
0 == undefined // false

undefined和null只有与自身比较，或者互相比较时，才会返回true；与其他类型的值比较时，结果都为false。

布尔值运算符

布尔运算符用于将表达式转为布尔值，一共包含四个运算符。

• 取反运算符：!

• 且运算符：&&

• 或运算符：||

• 三元运算符：?:

取反运算符是一个感叹号，用于将布尔值变为相反值，即true变成false，false变成true。

!true //false
!false //true

对于非布尔值，取反运算符会将其转为布尔值。可以这样记忆，以下六个值取反后为true，其他值都为false。

• undefined

• null

• false

• 0

• NaN

• 空字符串（''）

如果对一个值连续做两次取反运算，等于将其转为对应的布尔值，与Boolean函数的作用相同。这是一种常用的类型转换的写法。

!!x
// 等同于
Boolean(x)

且运算符（&&）一假则假

且运算符（&&）往往用于多个表达式的求值。

运算规则：第一个运算子为 true ，则返回第二个运算子的值(非布尔值);如果第一个运算子为false，则返回第一个运算子的值。

't' && '' // ""
't' && 'f' // "f"
't' && (1 + 2) // 3
'' && 'f' // ""
'' && '' // ""

let x = 1;
(1 - 1) && ( x += 1) // 0
x // 1

或运算符（||）一真则真

运算规则：第一个运算子为 true ，则返回第一个运算子的值(非布尔值);如果第一个运算子为false，则返回第二个运算子的值。

't' || '' // "t"
't' || 'f' // "t"
'' || 'f' // "f"
'' || '' // ""

三元条件运算符（?:）

如果第一个表达式的布尔值为true，则返回第二个表达式的值，否则返回第三个表达式的值。

true?'yes':'no' //'yes'
false? 'yes':'no' //no