11day

运算符，加减乘除一直都是语言的基础，和小学数据逻辑也很接近，可以说是简单的已经不能再简单了。但是在js中，总有让你打脸的地方

加法运算#
（1）加法运算符<code>（+）</code>是最常见的运算符之一，但是使用规则却
相对复杂。因为在JavaScript语言里面，这个运算符可以完成两种运算，既可以
处理算术的<b>加法</b>，也可以用作字符串<b>连接</b>。
加法

1 + 1 // 2 没有对象或字符串， 数值相加
true + true // 2 Number(true)==1
1 + true // 2
字符串连接

'111' + '111' // "111111"
'1.1' + '1.1' // "1.11.1"
1.如果运算子是对象，先自动转成原始类型的值。
即先执行该对象的<code>valueOf</code>方法，如果结果还不是原始类型的值，再执行<code>toString</code>方法；如果对象是<code>Date</code>实例，则先执行<code>toString</code>方法

2.两个运算子都是原始类型的值以后，只要有一个运算子是字符串，则两个运算子都转为字符串，执行字符串连接运算。
3.否则，两个运算子都转为数值，执行加法运算。

'1' + {foo: 'bar'} // "1[object Object]" 对象调用toString之后字符串相加
'1' + 1 // "11" 第一个是字符串，则使用字符串拼接
'1' + true // "1true"
'1' + [1] // "11"
上面代码中，由于运算符左边是一个字符串，导致右边的运算子都会先转为字符串，然后执行字符串连接运算。

这种由于参数不同，而改变自身行为的现象，叫做“重载”（overload）。由于加法运算符是运行时决定到底执行那种运算，使用的时候必须很小心。

'3' + 4 + 5 // "345"
3 + 4 + '5' // "75"
相等于

(3+4) + '5'
加法运算符会将其他类型的值，自动转为字符串，然后再执行连接运算。

var x = 1;
x + '' // "1" 转字符串1

1, 2] + [3] // 1,23
相等于

"1,2" + "3" // 数组先转为对应的字符串再进行拼接
（2）加法运算符一定有左右两个运算子，如果只有右边一个运算子，就是另一个运算符，叫做“数值运算符”。

• • 3 // 等同于 +(-3)
• 1 + 2 // 等同于 +(1 + 2)
• '1' // 1
  1 + // SyntaxError: Unexpected end of input
  <b>加法运算符以外的其他算术运算符（比如减法、除法和乘法），都不会发生重载。它们的规则是：所有运算子一律转为数值，再进行相应的数学运算。</b>

1 - '2' // -1
1 * '2' // 2
1 / '2' // 0.5
var now = new Date();
typeof (now + 1) // "string"
typeof (now - 1) // "number
余数运算符（%）#
需要注意的是，运算结果的正负号由第一个运算子的正负号决定。
-1 % 2 // -1
1 % -2 // 1
-1% -2 // -1负数对比自己小的数求余都是自身
-1 % -1 // -0
比较运算符的算法#
1.如果运算子是对象，先自动转成原始类型的值（即先执行该对象的valueOf方法，如果结果还不是原始类型的值，再执行toString方法）。
2.如果两个运算子都是字符串，则按照字典顺序比较（实际上是比较Unicode码点）。
3.否则，将两个运算子都转成数值，再进行比较。

[2] > [1] // true
等同于 '2' > '1'

[2] > [11] // true
等同于 '2' > '11'

{x: 2} > {x: 1} // false
等同于 '[object Object]' > '[object Object]'

相等运算符和严格相等运算符#
（1）简单说，它们的区别是相等运算符<code>（==）</code>比较两个值是否相等，严格相等运算符<code>（===）</code>比较它们是否为“同一个值”。如果两个值不是同一类型，严格相等运算符<code>（===）</code>直接返回false，而相等运算符<code>（==）</code>会将它们转化成同一个类型，再用严格相等运算符进行比较。

/*类型不同，直接返回false/
1 === "1" // false
true === "true" // false

/*类型相同且值相同/
1 === 0x1 // true 注：typeof 0x1 === "number"

NaN === NaN // false Nan与任何值都不相等
+0 === -0 // true 除了作为分母，它俩性质一样
（2）两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个对象。

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

var v1 = {};
var v2 = v1;
v1 === v2 // true
（3）<code>undefined</code>和<code>null</code>与自身严格相等，所以，判断两个参数时，还需谨慎。

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

var v1;
var v2;
v1 === v2 // true
（4）注意，对于两个对象的比较，严格相等运算符比较的是地址，而大于或小于运算符比较的是值。

new Date() > new Date() // false 值比较
new Date() < new Date() // false 值比较
new Date() === new Date() // false 地址比较
布尔值运算符#
5.1概述
布尔运算符用于将表达式转为布尔值，一共包含四个运算符。
取反运算符：!
且运算符：&
或运算符：||
三元运算符：?:
5.2 ！运算符

对于非布尔值的数据，取反运算符会自动将其转为布尔值。规则是，以下六个值取反后为<code>true</code>，其他值取反后都为<code>false</code>（取反运算符有转换数据类型的作用）。

!undefined // true
!null // true
!false // true
!0 // true（包括+0和-0）
!NaN // true
!'' // true

!54 // false
!'hello' // false
![] // false
!{} // false

!!x
等同于

Boolean(x)
5.3 且运算符
如果第一个运算子的布尔值为<code>true</code>，则返回第二个运算子的值（注意是值，不是布尔值）；如果第一个运算子的布尔值为<code>false</code>，则直接返回第一个运算子的值，且不再对第二个运算子求值。

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

var x = 1;
(1 - 1) && ( x += 1) // 0
x // 1
5.4 或运算符
如果第一个运算子的布尔值为<code>true</code>，则返回第一个运算子的值，且不再对第二个运算子求值；如果第一个运算子的布尔值为false，则返回第二个运算子的值。

't' || '' // "t"
't' || 'f' // "t"
'' || 'f' // "f"
'' || '' // ""
位运算符#
6.1 概述
或运算（or）：符号为|，表示若两个二进制位都为0，则结果为0，否则为1（有1则1）。
与运算（and）：符号为&，表示若两个二进制位都为1，则结果为1，否则为0（11则1）。
否运算（not）：符号为~，表示对一个二进制位取反。
异或运算（xor）：符号为^，表示若两个二进制位不相同，则结果为1，否则为0。（同0异1）
位运算符直接处理每一个比特位（bit），所以是非常底层的运算，好处是速度极快，缺点是很不直观。位运算符只对整数起作用，如果一个运算子不是整数，会自动转为整数后再执行。另外，虽然在JavaScript内部，数值都是以64位浮点数的形式储存，但是做位运算的时候，是以32位带符号的整数进行运算的，并且返回值也是一个32位带符号的整数。

转32为整数

function toInt32(x) {
return x | 0;
}
toInt32(1.001) // 1
toInt32(1.999) // 1
toInt32(1) // 1
toInt32(-1) // -1
一个整数大于32位的数位都会被舍去

toInt32(Math.pow(2, 32) + 1) // 1
toInt32(Math.pow(2, 32) - 1) // -1
6.2 或和与

0 | 3 // 3
0 & 3 // 0

*位运算只对整数有效，遇到小数时，会将小数部分舍去，只保留整数部分。
*所以，将一个小数与0进行或运算，等同于对该数去除小数部分，即取整数位
*不适用超过32位整数最大值2147483647的数
*/

2.9 | 0 // 2
-2.9 | 0 // -2