JavaScript-操作符

一元操作符

1.递增和递减操作符

• 前置操作符（++a / --a）
  变量的值是在求值以前被改变

var age = 29
var anotherage = --age+2 //30

• 后置操作符 （a++ / a–）
  递增和递减操作是在包含他们的语句被求值后才执行的

var num1 = 2
var num2 = 20
var num3 = num1-- + num2 // 22

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

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

var num1 = 'aaa'
console.log(num1++,num1) // NaN NaN
var num2 = '111aaa'
console.log(num2++,num2) // NaN NaN
var num3 = '111'
console.log(num3++,num3) // 111 112
var num4 = true
console.log(num4++,num4) // 1 2
var num5 = 1.1
console.log(num5--,num5) // 1.1 0.10000000000000009
var num6 = {
	valueOf:function(){
		return -1
	}
}
console.log(num6--,num6) //

2.一元加和减操作符

• 一元加操作符以一个（+）表示，放在数值前面对数值不会产生任何影响。在对非数值进行一元加操作时，该操作符会像Number()转型函数

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  //1
s2 = +s2  //1.1
s3 = +s3  //NaN
b = +b // 0
f = +f //1.1
o = +o //-1

• 一元减操作主要用于表示负数。在将一元减操作符应用于数值时，该值会变成负数。而当应用于非数值时，一元减操作符遵循与一元加操作符相同的规则，最后再将得到的值转换为负数

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  //-1
s2 = -s2  //-1.1
s3 = -s3  //NaN
b = -b // 0
f = -f //-1.1
o = -o //-1

布尔操作符

1. 逻辑非（!）
   逻辑非操作符遵循以下规则：

• 操作数是对象，返回false
• 操作数是空字符串，返回true
• 操作数是非空字符串，返回false
• 操作数是0，返回true
• 操作数是任意非0数值（包括Infinity）返回false
• 操作数是null，返回true
• 操作数是NaN返回true
• 操作数是undefined，返回true
  注：同时使用两个逻辑非操作符，实际上就会模拟Boolean()转型函数的行为

2. 逻辑与（&&）
   逻辑与操作可应用于任何类型的操作符。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值。它遵循下列规则

• 如果第一个操作数是对象，则返回第二个操作数
• 如果第二个操作数是对象，则只有在第一个操作符的求值结果为true的情况下才会返回该对象
• 如果两个操作数都是对象，则返回第二个操作数
• 如果有一个操作数是null，则返回null
• 如果有一个操作数是NaN，则返回NaN
• 如果有一个操作数是undefined，则返回undefined
  逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。

3. 逻辑或（||）
   如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值。它遵循如下规则：

• 第一个操作数是对象，则返回第一个操作数
• 第一个操作数的求值结果为false,则返回第二个操作数
• 如果两个操作数都是对象，则返回第一个操作数
• 如果两个操作数都是null,则返回null
• 如果两个操作数都是NaN，则返回NaN
• 如果两个操作数都是undefined，则返回undefined
  逻辑或操作符也是短路操作符，如果第一个操作数的求值结果为true，就不会对第二个操作数求值了

乘性操作符

如果参与乘性计算的某个操作数不是数值，后台会先使用Number(）转型函数将其转换为数值。

1. 乘法
   在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：

• 如果操作数都是数值，执行常规的乘法计算
• 如果有一个操作数是NaN，则结果是NaN
• 如果是Infinity与0相乘，则结果是NaN
• 如果是Infinity与非0数值相乘，则结果是Infinity或-Infinity
• 如果是Infinity与Infinity相乘，则结果是Infinity
• 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则

2. 除法
   特殊的处理规则：

• 如果操作数都是数值，执行常规的除法计算
• 如果有一个操作数是NaN，则结果是NaN
• 如果Infinity被Infinity除，则结果是NaN
• 如果是0被0除，则结果是NaN
• 如果是非0的有限数被0除，则结果是Infinity或-Infinity
• 如果是Infinity被任何非0数值除，则结果是Infinity或-Infinity
• 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则

console.log(Infinity/0) //Infinity
console.log(0/Infinity) //0
console.log(1/Infinity) //0
console.log(Infinity/Infinity)//NaN
console.log(0/0)//NaN

3. 求模（取余）
   求模操作符会遵循以下规则：

• 如果操作数都是数值，执行常规的除法计算，返回除得的余数
• 如果被除数是无穷大值而除数是有限大数值，则结果是NaN
• 如果被除数是有限大数值而除数是0，则结果是NaN
• 如果是Infinity被Infinity除，则结果是NaN
• 如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数
• 如果被除数是0，则结果是0
• 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则

console.log(Infinity % 5) //NaN
console.log(5 % 0) //NaN
console.log(Infinity % Infinity) //NaN
console.log(5 % Infinity) //5

加性操作符

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 //4
var result2 = NaN - 1 //NaN
var result3 = 5 - 3 //2
var result4 = 5 - ""//5
var result5 = 5 - "2" //3
var result6 = 5 - null //5

关系操作符（<,>,<=,>=）

相应规则

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

相等操作符

1. 相等和不相等（==和!=）

• 如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值
• 如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值
• 如果一个操作数是对象，另一个操作数不是，则调用对象的valueOf()方法，用得到的基本类型值按照前面的规则进行比较
• null==undefined
• 比较相等性之前，不能将null和undefined转换成其他任何值
• 如果有一个操作数是NaN，则相等操作符返回false，不相等操作符返回true。且NaN与NaN不相等
• 如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回true，否则返回false

null == undefined //true
"NaN" = NaN //false
5 == NaN //false
NaN == NaN //false
NaN != NaN //true
false == 0 //false
true == 1 //true
true == 2 //false
undefined == 0 //false
null == 0 //false
"5" == 5 //true

2. 全等和不全等（=== 和 !==）
   除了在比较之前不转换操作数之外，全等和不全等操作符与相等和不相等操作符没有什么区别。

逗号操作符

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

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