算術(shù)運算符
JavaScript 共提供10個算術(shù)運算符，用來完成基本的算術(shù)運算。
- 加法運算符：
x + y - 減法運算符：
x - y - 乘法運算符：
x * y - 除法運算符：
x / y - 指數(shù)運算符：
x ** y - 余數(shù)運算符：
x % y - 自增運算符：
++x或者x++ - 自減運算符：
--x或者x-- - 數(shù)值運算符：
+x -
負數(shù)值運算符：
-x
加法運算符是最常見的運算符，用來求兩個數(shù)值的和。js允許非數(shù)值的相加。下面代碼中，第一行是兩個布爾值相加，第二行是數(shù)值與布爾值相加。這兩種情況，布爾值都會自動轉(zhuǎn)成數(shù)值，然后再相加。
true+true //2
1+true //2
1+false //1
比較特殊的是，如果是兩個字符串相加，這時加法運算符會變成連接運算符，返回一個新的字符串，將兩個原字符串連接在一起。如果一個運算子是字符串，另一個運算子是非字符串，這時非字符串會轉(zhuǎn)成字符串，再連接在一起。
'a' + 'bc' // "abc"
1 + 'a' // "1a"
false + 'a' // "falsea"
加法運算符是在運行時決定，到底是執(zhí)行相加，還是執(zhí)行連接。也就是說，運算子的不同，導(dǎo)致了不同的語法行為，這種現(xiàn)象稱為“重載”（overload）。由于加法運算符存在重載，可能執(zhí)行兩種運算，使用的時候必須很小心。
'3' + 4 + 5 // "345"
3 + 4 + '5' // "75"
上面代碼中，由于從左到右的運算次序，字符串的位置不同會導(dǎo)致不同的結(jié)果。
除了加法運算符，其他算術(shù)運算符（比如減法、除法和乘法）都不會發(fā)生重載。它們的規(guī)則是：所有運算子一律轉(zhuǎn)為數(shù)值，再進行相應(yīng)的數(shù)學(xué)運算。
1 - '2' // -1
1 * '2' // 2
1 / '2' // 0.5
-
對象的相加
如果運算子是對象，必須先轉(zhuǎn)成原始類型的值，然后再相加。
var obj = { p: 1 };
obj + 2 // "[object Object]2"
上面代碼中，對象obj轉(zhuǎn)成原始類型的值是[object Object]，再加2就得到了上面的結(jié)果。
對象轉(zhuǎn)成原始類型的值，規(guī)則如下。
首先，自動調(diào)用對象的valueOf方法。
var obj = { p: 1 };
obj.valueOf() // { p: 1 }
一般來說，對象的valueOf方法總是返回對象自身，這時再自動調(diào)用對象的toString方法，將其轉(zhuǎn)為字符串。
var obj = { p: 1 };
obj.valueOf().toString() // "[object Object]"
對象的toString方法默認返回[object Object]，所以就得到了最前面那個例子的結(jié)果。知道了這個規(guī)則以后，就可以自己定義valueOf方法或toString方法，得到想要的結(jié)果。
var obj = {
valueOf: function () {
return 1;
}
};
obj + 2 // 3
上面代碼中，我們定義obj對象的valueOf方法返回1，于是obj + 2就得到了3。這個例子中，由于valueOf方法直接返回一個原始類型的值，所以不再調(diào)用toString方法。
下面是自定義toString方法的例子。
var obj = {
toString: function () {
return 'hello';
}
};
obj + 2 // "hello2"
上面代碼中，對象obj的toString方法返回字符串hello。前面說過，只要有一個運算子是字符串，加法運算符就變成連接運算符，返回連接后的字符串。
這里有一個特例，如果運算子是一個Date對象的實例，那么會優(yōu)先執(zhí)行toString方法。
var obj = new Date();
obj.valueOf = function () { return 1 };
obj.toString = function () { return 'hello' };
obj + 2 // "hello2"
上面代碼中，對象obj是一個Date對象的實例，并且自定義了valueOf方法和toString方法，結(jié)果toString方法優(yōu)先執(zhí)行。
余數(shù)運算符%返回前一個運算子被后一個運算子除，所得的余數(shù)。需要注意的是，運算結(jié)果的正負號由第一個運算子的正負號決定。所以，為了得到負數(shù)的正確余數(shù)值，可以先使用絕對值函數(shù)。
// 錯誤的寫法
function isOdd(n) {
return n % 2 === 1;
}
isOdd(-5) // false
isOdd(-4) // false
// 正確的寫法
function isOdd(n) {
return Math.abs(n % 2) === 1;
}
isOdd(-5) // true
isOdd(-4) // false
自增和自減運算符是一元運算符，只需要一個運算子。它們的作用是將運算子首先轉(zhuǎn)為數(shù)值，然后加上1或者減去1。它們會修改原始變量。自增和自減運算符有一個需要注意的地方，就是放在變量之后，會先返回變量操作前的值，再進行自增/自減操作；放在變量之前，會先進行自增/自減操作，再返回變量操作后的值。
var x = 1;
var y = 1;
x++ // 1
++y // 2
數(shù)值運算符（+）同樣使用加號，但它是一元運算符（只需要一個操作數(shù)），而加法運算符是二元運算符（需要兩個操作數(shù)）。
數(shù)值運算符的作用在于可以將任何值轉(zhuǎn)為數(shù)值（與Number函數(shù)的作用相同）。下面代碼表示，非數(shù)值經(jīng)過數(shù)值運算符以后，都變成了數(shù)值（最后一行NaN也是數(shù)值）。
+true // 1
+[] // 0
+{} // NaN
負數(shù)值運算符（-），也同樣具有將一個值轉(zhuǎn)為數(shù)值的功能，只不過得到的值正負相反。連用兩個負數(shù)值運算符，等同于數(shù)值運算符。下面代碼最后一行的圓括號不可少，否則會變成自減運算符。
var x = 1;
-x // -1
-(-x) // 1
數(shù)值運算符號和負數(shù)值運算符，都會返回一個新的值，而不會改變原始變量的值。
指數(shù)運算符（）**完成指數(shù)運算，前一個運算子是底數(shù)，后一個運算子是指數(shù)。注意，指數(shù)運算符是右結(jié)合，而不是左結(jié)合。即多個指數(shù)運算符連用時，先進行最右邊的計算。
2 ** 4 // 16
2 ** 3 ** 2 // 相當于 2 ** (3 ** 2)
// 512
上面代碼中，由于指數(shù)運算符是右結(jié)合，所以先計算第二個指數(shù)運算符，而不是第一個。
賦值運算符（Assignment Operators）用于給變量賦值。最常見的賦值運算符，當然就是等號（=）。賦值運算符還可以與其他運算符結(jié)合，形成變體。下面是與算術(shù)運算符的結(jié)合。
// 將 1 賦值給變量 x
var x = 1;
// 將變量 y 的值賦值給變量 x
var x = y;
x += y // 等同于 x = x + y
x -= y // 等同于 x = x - y
x *= y // 等同于 x = x * y
x /= y // 等同于 x = x / y
x %= y // 等同于 x = x % y
x **= y // 等同于 x = x ** y
下面是與位運算符的結(jié)合。這些復(fù)合的賦值運算符，都是先進行指定運算，然后將得到值返回給左邊的變量。
x >>= y // 等同于 x = x >> y
x <<= y // 等同于 x = x << y
x >>>= y // 等同于 x = x >>> y
x &= y // 等同于 x = x & y
x |= y // 等同于 x = x | y
x ^= y // 等同于 x = x ^ y
比較運算符
比較運算符用于比較兩個值的大小，然后返回一個布爾值，表示是否滿足指定的條件。
注意，比較運算符可以比較各種類型的值，不僅僅是數(shù)值。
JavaScript 一共提供了8個比較運算符。
>大于運算符<小于運算符<=小于或等于運算符>=大于或等于運算符==相等運算符===嚴格相等運算符!=不相等運算符!==嚴格不相等運算符
這八個比較運算符分成兩類：相等比較和非相等比較。兩者的規(guī)則是不一樣的，對于非相等的比較，算法是先看兩個運算子是否都是字符串，如果是的，就按照字典順序比較（實際上是比較 Unicode 碼點）；否則，將兩個運算子都轉(zhuǎn)成數(shù)值，再比較數(shù)值的大小。
非相等運算符：字符串的比較，字符串按照字典順序進行比較。JavaScript 引擎內(nèi)部首先比較首字符的 Unicode 碼點。如果相等，再比較第二個字符的 Unicode 碼點，以此類推。
非相等運算符：非字符串的比較，如果兩個運算子都不是字符串，分成以下兩種情況。
- 原始類型值
如果兩個運算子都是原始類型的值，則是先轉(zhuǎn)成數(shù)值再比較。
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
任何值（包括NaN本身）與NaN比較，返回的都是false。
1 > NaN // false
1 <= NaN // false
'1' > NaN // false
'1' <= NaN // false
NaN > NaN // false
NaN <= NaN // false
- 對象
如果運算子是對象，會轉(zhuǎn)為原始類型的值，再進行比較。對象轉(zhuǎn)換成原始類型的值，算法是先調(diào)用valueOf方法；如果返回的還是對象，再接著調(diào)用toString方法
var x = [2];
x > '11' // true
// 等同于 [2].valueOf().toString() > '11'
// 即 '2' > '11'
x.valueOf = function () { return '1' };
x > '11' // false
// 等同于 [2].valueOf() > '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 提供兩種相等運算符：==和===。簡單說，它們的區(qū)別是相等運算符（==）比較兩個值是否相等，嚴格相等運算符（===）比較它們是否為“同一個值”。如果兩個值不是同一類型，嚴格相等運算符（===）直接返回false，而相等運算符（==）會將它們轉(zhuǎn)換成同一個類型，再用嚴格相等運算符進行比較。
- 嚴格相等運算下：
需要注意的是，NaN與任何值都不相等（包括自身）。另外，正0等于負0。
兩個復(fù)合類型（對象、數(shù)組、函數(shù)）的數(shù)據(jù)比較時，不是比較它們的值是否相等，而是比較它們是否指向同一個地址。
{} === {} // false
[] === [] // false
(function () {} === function () {}) // false
上面代碼分別比較兩個空對象、兩個空數(shù)組、兩個空函數(shù)，結(jié)果都是不相等。原因是對于復(fù)合類型的值，嚴格相等運算比較的是，它們是否引用同一個內(nèi)存地址，而運算符兩邊的空對象、空數(shù)組、空函數(shù)的值，都存放在不同的內(nèi)存地址，結(jié)果當然是false。如果兩個變量引用同一個對象，則它們相等。
var v1 = {};
var v2 = v1;
v1 === v2 // true
注意，對于兩個對象的比較，嚴格相等運算符比較的是地址，而大于或小于運算符比較的是值。
var obj1 = {};
var obj2 = {};
obj1 > obj2 // false
obj1 < obj2 // false
obj1 === obj2 // false
上面的三個比較，前兩個比較的是值，最后一個比較的是地址，所以都返回false。
undefined和null與自身嚴格相等。
undefined === undefined // true
null === null // true
var v1;
var v2;
v1 === v2 // true
嚴格相等運算符有一個對應(yīng)的“嚴格不相等運算符”（!==），它的算法就是先求嚴格相等運算符的結(jié)果，然后返回相反值。
相等運算
相等運算符用來比較相同類型的數(shù)據(jù)時，與嚴格相等運算符完全一樣。比較不同類型的數(shù)據(jù)時，相等運算符會先將數(shù)據(jù)進行類型轉(zhuǎn)換，然后再用嚴格相等運算符比較。下面分成四種情況，討論不同類型的值互相比較的規(guī)則。
- 原始類型值。原始類型的值會轉(zhuǎn)換成數(shù)值再進行比較。
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
'' == false // true
// 等同于 Number('') === Number(false)
// 等同于 0 === 0
'1' == true // true
// 等同于 Number('1') === Number(true)
// 等同于 1 === 1
'\n 123 \t' == 123 // true
// 因為字符串轉(zhuǎn)為數(shù)字時，省略前置和后置的空格
- 對象與原始類型值比較。對象（這里指廣義的對象，包括數(shù)組和函數(shù)）與原始類型的值比較時，對象轉(zhuǎn)換成原始類型的值，再進行比較。
// 對象與數(shù)值比較時，對象轉(zhuǎn)為數(shù)值
[1] == 1 // true
// 等同于 Number([1]) == 1
// 對象與字符串比較時，對象轉(zhuǎn)為字符串
[1] == '1' // true
// 等同于 String([1]) == '1'
[1, 2] == '1,2' // true
// 等同于 String([1, 2]) == '1,2'
// 對象與布爾值比較時，兩邊都轉(zhuǎn)為數(shù)值
[1] == true // true
// 等同于 Number([1]) == Number(true)
[2] == true // false
// 等同于 Number([2]) == Number(true)
undefined和null與其他類型的值比較時，結(jié)果都為false，它們互相比較時結(jié)果為true。
布爾運算符
布爾運算符用于將表達式轉(zhuǎn)為布爾值，一共包含四個運算符。
- 取反運算符：
! - 且運算符：
&& - 或運算符：
|| - 三元運算符：
？：
取反運算符是一個感嘆號，用于將布爾值變?yōu)橄喾粗担?code>true變成false，false變成true。對于非布爾值，取反運算符會將其轉(zhuǎn)為布爾值?？梢赃@樣記憶，以下六個值取反后為true，其他值都為false。
undefined、null、false、0、NaN、空字符串(' ')
如果對一個值連續(xù)做兩次取反運算，等于將其轉(zhuǎn)為對應(yīng)的布爾值，與Boolean函數(shù)的作用相同。這是一種常用的類型轉(zhuǎn)換的寫法。
!!x
//等同于
Boolean(x)
上面代碼中，不管x是什么類型的值，經(jīng)過兩次取反運算后，變成了與Boolean函數(shù)結(jié)果相同的布爾值。所以，兩次取反就是將一個值轉(zhuǎn)為布爾值的簡便寫法。
且運算符（&&）往往用于多個表達式的求值。它的運算規(guī)則是：如果第一個運算子的布爾值為true，則返回第二個運算子的值（注意是值，不是布爾值）；如果第一個運算子的布爾值為false，則直接返回第一個運算子的值，且不再對第二個運算子求值。
't' && '' // ""
't' && 'f' // "f"
't' && (1 + 2) // 3
'' && 'f' // ""
'' && '' // ""
var x = 1;
(1 - 1) && ( x += 1) // 0
x // 1
上面代碼的最后一個例子，由于且運算符的第一個運算子的布爾值為false，則直接返回它的值0，而不再對第二個運算子求值，所以變量x的值沒變。
這種跳過第二個運算子的機制，被稱為“短路”。有些程序員喜歡用它取代if結(jié)構(gòu)，比如下面是一段if結(jié)構(gòu)的代碼，就可以用且運算符改寫。
if (i) {
doSomething();
}
// 等價于
i && doSomething();
上面代碼的兩種寫法是等價的，但是后一種不容易看出目的，也不容易除錯，建議謹慎使用。且運算符可以多個連用，這時返回第一個布爾值為false的表達式的值。如果所有表達式的布爾值都為true，則返回最后一個表達式的值。
true && 'foo' && '' && 4 && 'foo' && true
// ''
1 && 2 && 3
// 3
上面代碼中，例一里面，第一個布爾值為false的表達式為第三個表達式，所以得到一個空字符串。例二里面，所有表達式的布爾值都是true，所有返回最后一個表達式的值3。
或運算符（||）也用于多個表達式的求值。它的運算規(guī)則是：如果第一個運算子的布爾值為true，則返回第一個運算子的值，且不再對第二個運算子求值；如果第一個運算子的布爾值為false，則返回第二個運算子的值。短路規(guī)則對這個運算符也適用。
't' || '' // "t"
't' || 'f' // "t"
'' || 'f' // "f"
'' || '' // ""
var x = 1;
true || (x = 2) // true
x // 1
上面代碼中，且運算符的第一個運算子為true，所以直接返回true，不再運行第二個運算子。所以，x的值沒有改變。這種只通過第一個表達式的值，控制是否運行第二個表達式的機制，就稱為“短路”（short-cut）。
function saveText(text) {
text = text || '';
// ...
}
// 或者寫成
saveText(this.text || '')
或運算符常用于為一個變量設(shè)置默認值。上面代碼表示，如果函數(shù)調(diào)用時，沒有提供參數(shù)，則該參數(shù)默認設(shè)置為空字符串。
三元條件運算符由問號（?）和冒號（:）組成，分隔三個表達式。它是 JavaScript 語言唯一一個需要三個運算子的運算符。如果第一個表達式的布爾值為true，則返回第二個表達式的值，否則返回第三個表達式的值。
't' ? 'hello' : 'world' // "hello"
0 ? 'hello' : 'world' // "world"
上面代碼的t和0的布爾值分別為true和false，所以分別返回第二個和第三個表達式的值。
通常來說，三元條件表達式與if...else語句具有同樣表達效果，前者可以表達的，后者也能表達。但是兩者具有一個重大差別，if...else是語句，沒有返回值；三元條件表達式是表達式，具有返回值。所以，在需要返回值的場合，只能使用三元條件表達式，而不能使用if..else。
二進制運算符
二進制位運算符用于直接對二進制位進行計算，一共有7個。
-
二進制或運算符（or）：符號為
|，表示若兩個二進制位都為0，則結(jié)果為0，否則為1。 -
二進制與運算符（and）：符號為
&，表示若兩個二進制位都為1，則結(jié)果為1，否則為0。 -
二進制否運算符（not）：符號為
~，表示對一個二進制位取反。 -
異或運算符（xor）：符號為
^，表示若兩個二進制位不相同，則結(jié)果為1，否則為0。 -
左移運算符（left shift）：符號為
<<。 -
右移運算符（right shift）：符號為
>>。 -
帶符號位的右移運算符（zero filld right shift）：符號為
>>>。
因為個人對二進制不是很懂，所以這些只是記住概念和能用到的用法。
二進制否運算符，可以簡單記憶成，一個數(shù)與自身的取反值相加，等于-1。對一個整數(shù)連續(xù)兩次二進制否運算，得到它自身。所有的位運算都只對整數(shù)有效。二進制否運算遇到小數(shù)時，也會將小數(shù)部分舍去，只保留整數(shù)部分。所以，對一個小數(shù)連續(xù)進行兩次二進制否運算，能達到取整效果。使用二進制否運算取整，是所有取整方法中最快的一種。
~~2.9 // 2
~~47.11 // 47
~~1.9999 // 1
~~3 // 3
異或運算（^）在兩個二進制位不同時返回1，相同時返回0?！爱惢蜻\算”有一個特殊運用，連續(xù)對兩個數(shù)a和b進行三次異或運算，a^=b; b^=a; a^=b;，可以互換它們的值。這意味著，使用“異或運算”可以在不引入臨時變量的前提下，互換兩個變量的值。這是互換兩個變量的值的最快方法。
var a = 10;
var b = 99;
a ^= b, b ^= a, a ^= b;
a // 99
b // 10
異或運算也可以用來取整。
12.9 ^ 0 // 12
可以利用二進制運算符設(shè)置開關(guān)，這個用到再來查資料吧。
其他運算符，運算順序
void運算符的作用是執(zhí)行一個表達式，然后不返回任何值，或者說返回undefined。
void 0 // undefined
void(0) // undefined
上面是void運算符的兩種寫法，都正確。建議采用后一種形式，即總是使用圓括號。因為void運算符的優(yōu)先性很高，如果不使用括號，容易造成錯誤的結(jié)果。比如，void 4 + 7實際上等同于(void 4) + 7。
下面是void運算符的一個例子。
var x = 3;
void (x = 5) //undefined
x // 5
這個運算符的主要用途是瀏覽器的書簽工具（bookmarklet），以及在超級鏈接中插入代碼防止網(wǎng)頁跳轉(zhuǎn)。
請看下面的代碼。
<script>
function f() {
console.log('Hello World');
}
</script>
<a onclick="f(); return false;">點擊</a>
上面代碼中，點擊鏈接后，會先執(zhí)行onclick的代碼，由于onclick返回false，所以瀏覽器不會跳轉(zhuǎn)到example.com。
void運算符可以取代上面的寫法。
<a href="javascript: void(f())">文字</a>
下面是一個更實際的例子，用戶點擊鏈接提交表單，但是不產(chǎn)生頁面跳轉(zhuǎn)。
<a href="javascript: void(document.form.submit())">
提交
</a>
逗號運算符用于對兩個表達式求值，并返回后一個表達式的值。
'a', 'b' // "b"
var x = 0;
var y = (x++, 10);
x // 1
y // 10
上面代碼中，逗號運算符返回后一個表達式的值。
逗號運算符的一個用途是，在返回一個值之前，進行一些輔助操作。下面代碼中，先執(zhí)行逗號之前的操作，然后返回逗號后面的值。
var value = (console.log('Hi!'), true);
// Hi!
value // true
-
運算順序
優(yōu)先級，js各種運算符的優(yōu)先級別是不一樣的。優(yōu)先級高的運算符先執(zhí)行，優(yōu)先級低的運算符后執(zhí)行。
乘法運算符（*）和除法運算符（/）優(yōu)先級高于加法運算符（+）和減法運算符（-），記住所有運算符的優(yōu)先級，是非常難的，也是沒有必要的。
var x = 1;
var arr = [];
var y = arr.length <= 0 || arr[0] === undefined ? x : arr[0];
上面代碼中，變量y的值就很難看出來，因為這個表達式涉及5個運算符，到底誰的優(yōu)先級最高，實在不容易記住。
根據(jù)語言規(guī)格，這五個運算符的優(yōu)先級從高到低依次為：小于等于（<=)、嚴格相等（===）、或（||）、三元（?:）、等號（=）。
圓括號（()）可以用來提高運算的優(yōu)先級，因為它的優(yōu)先級是最高的，即圓括號中的表達式會第一個運算。運算符的優(yōu)先級別十分繁雜，且都是硬性規(guī)定，因此建議總是使用圓括號，保證運算順序清晰可讀，這對代碼的維護和除錯至關(guān)重要。圓括號不是運算符，而是一種語法結(jié)構(gòu)。它一共有兩種用法：一種是把表達式放在圓括號之中，提升運算的優(yōu)先級；另一種是跟在函數(shù)的后面，作用是調(diào)用函數(shù)。圓括號之中，只能放置表達式，如果將語句放在圓括號之中，就會報錯。
左結(jié)合與右結(jié)合，對于優(yōu)先級別相同的運算符，大多數(shù)情況，計算順序總是從左到右，這叫做運算符的“左結(jié)合”（left-to-right associativity），即從左邊開始計算。但是少數(shù)運算符的計算順序是從右到左，即從右邊開始計算，這叫做運算符的“右結(jié)合”（right-to-left associativity）。其中，最主要的是賦值運算符（=）和三元條件運算符（?:）。指數(shù)運算符（**）也是右結(jié)合的。
