運算符是用來處理數據的基本方法。JavaScript與其他編程語言一樣，提供了多種運算符。 [TOC] ## 算術運算符 JavaScript提供9個算術運算符。 * 加法運算符（Addition）：x + y * 減法運算符（Subtraction）： x - y * 乘法運算符（Multiplication）： x * y * 除法運算符（Division）：x / y * 余數運算符（Remainder）：x % y * 自增運算符（Increment）：++x 或者 x++ * 自減運算符（Decrement）：--x 或者 x-- * 求負運算符（Negate）：-x * 數值運算符（Convert to number）： +x ### 加法運算符 加法運算符（+）需要注意的地方是，它除了用于數值的相加，還能用于字符串的連接。 ~~~ 2014-02-19 1 + 1 // 2 "1" + "1" // "11" ~~~ 兩個運算子之中只要有一個是字符串，加法運算符號就會變為字符串連接運算符，返回連接后的字符串，其他情況則是返回數值相加的和。這種由于參數不同，而改變自身行為的現象，叫做“重載”（overload）。 ~~~ 1 + "1" // "11" ~~~ 上面代碼表示，兩個運算子之中有一個是字符串，另一個運算子就會被自動轉為字符串。 ~~~ "3" + 4 + 5 // "345" 3 + 4 + "5" // "75" ~~~ 上面代碼中，由于加法運算符遇到字符串，會發生重載，導致運算結果的不同。 由于這個特性，下面的寫法有時用于將一個值轉為字符串。 ~~~ x + "" ~~~ 上面代碼表示，一個值加上空字符串，會使得該值轉為字符串形式。 布爾值和復合類型的值，也可以使用加法運算符，但是會導致數據類型的自動轉換，關于這方面的詳細討論，參見《數據類型轉換》一節。 加法運算符以外的其他算術運算符，都不會發生重載。它們的規則是：所有運算子一律轉為數值，再進行相應的數學運算。 ~~~ 1 - "1" // 0 +"3" // 3 -true // -1 ~~~ 上面代碼表示，減法運算符將字符串“1”自動轉為數值1，數值運算符（+）將字符串“3”轉為數值3，求負運算符（-）將布爾值true轉為-1。 由于加法運算符與其他算術運算符的這種差異，會導致一些意想不到的結果，計算時要小心。 ~~~ var now = new Date(); typeof (now + 1) // "string" typeof (now - 1) // "number" ~~~ 上面代碼中，now是一個Date對象的實例。加法運算時，now轉為字符串，加一個數字，得到還是字符串；減法運算時，now轉為數值，減一個數字，得到的是數字。 ### 余數運算符 余數運算符返回前一個運算子被后一個運算子除，所得的余數。 ~~~ 12 % 5 // 2 ~~~ 需要注意的是，運算結果的正負號由第一個運算子的正負號決定。 ~~~ -1 % 2 // -1 1 % -2 // 1 ~~~ 為了得到正確的負數的余數值，需要先使用絕對值函數。 ~~~ // 錯誤的寫法 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 ~~~ 余數運算符還可以用于浮點數的運算。但是，由于浮點數不是精確的值，無法得到完全準確的結果。 ~~~ 6.5 % 2.1 // 0.19999999999999973 ~~~ ### 自增和自減運算符 自增和自減運算符，是一元運算符，只需要一個運算子。它們的作用是將運算子首先轉為數值，然后加上1或者減去1。 ~~~ var x = "1"; ++x // 2 ~~~ 上面代碼的x是一個字符串，使用遞增運算符后，x首先被轉為數值1，然后進行遞增，返回2。 它們有一個需要注意的地方，就是放在變量之后，表示先返回變量操作前的值，再進行遞增/遞減操作；放在變量之前，表示先進行遞增/遞減操作，再返回變量操作后的值。 ~~~ var x1 = 1; var x2 = 1; x1++ // 1 ++x2 // 2 ~~~ 上面代碼中，x1是先返回后遞增，所以得到1；x2是先遞增后返回，所以得到2。 ### 數值運算符 數值運算符（+）同樣使用加號，但是加法運算符是二元運算符（需要兩個操作數），它是一元運算符（只需要一個操作數）。 它的重要作用在于可以將任何值轉為數值（與Number函數的作用相同）。 ~~~ +true // 1 +[] // 0 +{} // NaN ~~~ 上面代碼表示，非數值類型的值經過數值運算符以后，都變成了數值（包括最后一個NaN）。具體的類型轉換規則，參見《數據類型轉換》一節。 求負運算符（-），也同樣具有將一個值轉為數值的功能，所以下面的寫法等同于求值運算符。 ~~~ -(-x) ~~~ 上面代碼的圓括號不可少，否則會變成遞減運算符。 ## 賦值運算符 賦值運算符（Assignment Operators）用于給變量賦值。 最常見的賦值運算符，當然就是等號（=），表達式`x=y`表示將y賦值給x。除此之外，JavaScript還提供其他11個賦值運算符。 ~~~ 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 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 ~~~ ## 比較運算符 比較運算符比較兩個值，然后返回一個布爾值，表示是否滿足比較條件。JavaScript提供了8個比較運算符。 * ==?相等 * ===?嚴格相等 * !=?不相等 * !==?嚴格不相等 * ?小于 * ?小于或等于 * >?大于 * >=?大于或等于 其中，比較兩個值是否相等的運算符有兩個：一個是相等運算符（==），另一個是嚴格相等運算符（===）。 相等運算符（==）比較兩個“值”是否相等，嚴格相等運算符（===）比較它們是否為“同一個值”。兩者的一個重要區別是，如果兩個值不是同一類型，嚴格相等運算符（===）直接返回false，而相等運算符（==）會將它們轉化成同一個類型，再用嚴格相等運算符進行比較。 我們先看嚴格相等運算符。 ### 嚴格相等運算符 嚴格相等運算符的運算規則如下： （1）不同類型的值 如果兩個值的類型不同，直接返回false。 ~~~ 1 === "1" // false true === "true" // false ~~~ 上面代碼比較數值的1與字符串的“1”、布爾值的true與字符串“true”，因為類型不同，結果都是false。 （2）同一類的原始類型值 同一類型的原始類型的值（數值、字符串、布爾值）比較時，值相同就返回true，值不同就返回false。 ~~~ 1 === 0x1 // true ~~~ 上面代碼比較十進制的1與十六進制的1，因為類型和值都相同，返回true。 需要注意的是，NaN與任何值都不相等（包括自身）。另外，正0等于負0。 ~~~ NaN === NaN // false +0 === -0 // true ~~~ （3）同一類的復合類型值 兩個復合類型（對象、數組、函數）的數據比較時，不是比較它們的值是否相等，而是比較它們是否指向同一個對象。 ~~~ ({}) === {} // false [] === [] // false (function (){}) === function (){} // false ~~~ 上面代碼分別比較兩個空對象、兩個空數組、兩個空函數，結果都是不相等。原因是對于復合類型的值，嚴格相等運算比較的是它們的內存地址是否一樣，而上面代碼中空對象、空數組、空函數的值，都存放在不同的內存地址，結果當然是false。另外，之所以要把第一個空對象放在括號內，是為了避免JavaScript引擎把這一行解釋成代碼塊，從而報錯；把第一個空函數放在括號內，是為了避免這一行被解釋成函數的定義。 如果兩個變量指向同一個復合類型的數據，則它們相等。 ~~~ var v1 = {}; var v2 = v1; v1 === v2 // true ~~~ （4）undefined和null undefined 和 null 與自身嚴格相等。 ~~~ undefined === undefined // true null === null // true ~~~ 由于變量聲明后默認值是undefined，因此兩個只聲明未賦值的變量是相等的。 ~~~ var v1; var v2; v1 === v2 // true ~~~ （5）嚴格不相等運算符 嚴格相等運算符有一個對應的“嚴格不相等運算符”（!==），兩者的運算結果正好相反。 ~~~ 1 !== "1" // true ~~~ ### 相等運算符 相等運算符在比較相同類型的數據時，與嚴格相等運算符完全一樣。 在比較不同類型的數據時，相等運算符會先將數據進行類型轉換，然后再用嚴格相等運算符比較。類型轉換規則如下： （1）原始類型的值 原始類型的數據會轉換成數值類型再進行比較。 ~~~ 1 == true // true 0 == false // true "true" == true // false '' == 0 // true '' == false // true '1' == true // true "2" == true // false 2 == true // false 2 == false // false '\n 123 \t' == 123 // true // 因為字符串轉為數字時，省略前置和后置的空格 ~~~ 上面代碼將字符串和布爾值都轉為數值，然后再進行比較。字符串與布爾值的類型轉換規則，參見《數據類型轉換》一節。 （2）對象與原始類型值比較 對象（這里指廣義的對象，包括數值和函數）與原始類型的值比較時，對象轉化成原始類型的值，再進行比較。 ~~~ [1] == 1 // true [1] == "1" // true [1] == true // true ~~~ 上面代碼將只含有數值1的數組與原始類型的值進行比較，數組[1]會被自動轉換成數值1，因此結果都是true。數組的類型轉換規則，參見《數據類型轉換》一節。 （3）undefined和null undefined和null與其他類型的值比較時，結果都為false，它們互相比較時結果為true。 ~~~ false == null // false 0 == null // false undefined == null // true ~~~ （4）相等運算符的缺點 相等運算符隱藏的類型轉換，會帶來一些違反直覺的結果。 ~~~ '' == '0' // false 0 == '' // true 0 == '0' // true false == 'false' // false false == '0' // true false == undefined // false false == null // false null == undefined // true ' \t\r\n ' == 0 // true ~~~ 上面這些表達式都很容易出錯，因此不要使用相等運算符（==），最好只使用嚴格相等運算符（===）。 （5）不相等運算符 相等運算符有一個對應的“不相等運算符”（!=），兩者的運算結果正好相反。 ~~~ 1 != "1" // false ~~~ ## 布爾運算符 布爾運算符用于將表達式轉為布爾值。 ### 取反運算符（!） 取反運算符形式上是一個感嘆號，用于將布爾值變為相反值，即true變成false，false變成true。 ~~~ !true // false !false // true ~~~ 對于非布爾值的數據，取反運算符會自動將其轉為布爾值。規則是，以下六個值取反后為true，其他值取反后都為false。 * undefined * null * false * 0（包括+0和-0） * NaN * 空字符串（""） 這意味著，取反運算符有轉換數據類型的作用。 ~~~ !undefined // true !null // true !0 // true !NaN // true !"" // true !54 // false !'hello' // false ![] // false !{} // false ~~~ 上面代碼中，不管什么類型的值，經過取反運算后，都變成了布爾值。 如果對一個值連續做兩次取反運算，等于將其轉為對應的布爾值，與Boolean函數的作用相同。這是一種常用的類型轉換的寫法。 ~~~ !!x // 等同于 Boolean(x) ~~~ 上面代碼中，不管x是什么類型的值，經過兩次取反運算后，變成了與Boolean函數結果相同的布爾值。所以，兩次取反就是將一個值轉為布爾值的簡便寫法。 取反運算符的這種將任意數據自動轉為布爾值的功能，對下面三種布爾運算符（且運算符、或運算符、三元條件運算符）都成立。 ### 且運算符（&&） 且運算符的運算規則是：如果第一個運算子的布爾值為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結構，比如下面是一段if結構的代碼，就可以用且運算符改寫。 ~~~ if (i !== 0 ){ doSomething(); } // 等價于 i && doSomething(); ~~~ 上面代碼的兩種寫法是等價的，但是后一種不容易看出目的，也不容易除錯，建議謹慎使用。 且運算符可以多個連用，這時返回第一個布爾值為false的表達式的值。 ~~~ true && 'foo' && '' && 4 && 'foo' && true // '' ~~~ 上面代碼中第一個布爾值為false的表達式為第三個表達式，所以得到一個空字符串。 ### 或運算符（||） 或運算符的運算規則是：如果第一個運算子的布爾值為true，則返回第一個運算子的值，且不再對第二個運算子求值；如果第一個運算子的布爾值為false，則返回第二個運算子的值。 ~~~ "t" || "" // "t" "t" || "f" // "t" "" || "f" // "f" "" || "" // "" ~~~ 短路規則對這個運算符也適用。 或運算符可以多個連用，這時返回第一個布爾值為true的表達式的值。 ~~~ false || 0 || '' || 4 || 'foo' || true // 4 ~~~ 上面代碼中第一個布爾值為true的表達式是第四個表達式，所以得到數值4。 或運算符常用于為一個變量設置默認值。 ~~~ function saveText(text) { text = text || ''; // ... } // 或者寫成 saveText(this.text||'') ~~~ 上面代碼表示，如果函數調用時，沒有提供參數，則該參數默認設置為空字符串。 ### 三元條件運算符（ ? :） 三元條件運算符用問號（？）和冒號（：），分隔三個表達式。如果第一個表達式的布爾值為true，則返回第二個表達式的值，否則返回第三個表達式的值。 ~~~ "t" ? true : false // true 0 ? true : false // false ~~~ 上面代碼的“t”和0的布爾值分別為true和false，所以分別返回第二個和第三個表達式的值。 通常來說，三元條件表達式與if...else語句具有同樣表達效果，前者可以表達的，后者也能表達。但是兩者具有一個重大差別，if...else是語句，沒有返回值；三元條件表達式是表達式，具有返回值。所以，在需要返回值的場合，只能使用三元條件表達式，而不能使用if..else。 ~~~ var check = true ? console.log('T') : console.log('F'); console.log(true ? 'T' : 'F'); ~~~ 上面代碼是賦值語句和console.log方法的例子，它們都需要使用表達式，這時三元條件表達式就能滿足需要。如果要用if...else語句，就必須改變整個代碼寫法了。 ## 位運算符 ### 簡介 位運算符用于直接對二進制位進行計算，一共有7個。 * 或運算（or）：符號為|，表示兩個二進制位中有一個為1，則結果為1，否則為0。 * 與運算（and）：符號為&，表示兩個二進制位都為1，則結果為1，否則為0。 * 否運算（not）：符號為～，表示將一個二進制位變成相反值。 * 異或運算（xor）：符號為?，表示兩個二進制位中有且僅有一個為1時，結果為1，否則為0。 * 左移運算（left shift）：符號為<<，詳見下文解釋。 * 右移運算（right shift）：符號為>>，詳見下文解釋。 * 帶符號位的右移運算（zero filled right shift）：符號為>>>，詳見下文解釋。 這些位運算符直接處理每一個比特位，所以是非常底層的運算，好處是速度極快，缺點是很不直觀，許多場合不能使用它們，否則會帶來過度的復雜性。 有一點需要特別注意，位運算符只對整數起作用，如果一個運算子不是整數，會自動轉為整數后再運行。另外，雖然在JavaScript內部，數值都是以64位浮點數的形式儲存，但是做位運算的時候，是以32位帶符號的整數進行運算的，并且返回值也是一個32位帶符號的整數。 ~~~ i = i|0; ~~~ 上面這行代碼的意思，就是將i轉為32位整數。 ### “或運算”與“與運算” 這兩種運算比較容易理解，就是逐位比較兩個運算子。“或運算”的規則是，如果兩個二進制位之中至少有一個位為1，則返回1，否則返回0。“與運算”的規則是，如果兩個二進制位之中至少有一個位1為0，則返回0，否則返回1。 ~~~ 0 | 3 // 3 0 & 3 // 0 ~~~ 上面兩個表達式，0和3的二進制形式分別是00和11，所以進行“或運算”會得到11（即3），進行”與運算“會得到00（即0）。 位運算只對整數有效，遇到小數時，會將小數部分舍去，只保留整數部分。所以，將一個小數與0進行或運算，等同于對該數去除小數部分，即取整數位。 ~~~ 2.9 | 0 // 2 -2.9 | 0 // -2 ~~~ 需要注意的是，這種取整方法不適用超過32位整數最大值2147483647的數。 ~~~ 2147483649.4 | 0; // -2147483647 ~~~ ### 否運算 “否運算”將每個二進制位都變為相反值（0變為1，1變為0）。它的返回結果有時比較難理解，因為涉及到計算機內部的數值表示機制。 ~~~ ~ 3 // -4 ~~~ 上面表達式對3進行“否運算”，得到-4。之所以會有這樣的結果，是因為位運算時，JavaScirpt內部將所有的運算子都轉為32位的二進制整數再進行運算。3在JavaScript內部是00000000000000000000000000000011，否運算以后得到11111111111111111111111111111100，由于第一位是1，所以這個數是一個負數。JavaScript內部采用2的補碼形式表示負數，即需要將這個數減去1，再取一次反，然后加上負號，才能得到這個負數對應的10進制值。這個數減去1等于11111111111111111111111111111011，再取一次反得到00000000000000000000000000000100，再加上負號就是-4。考慮到這樣的過程比較麻煩，可以簡單記憶成，一個數與自身的取反值相加，等于-1。 ~~~ ~ -3 // 2 ~~~ 上面表達式可以這樣算，-3的取反值等于-1減去-3，結果為2。 對一個整數連續兩次“否運算”，得到它自身。 ~~~ ~~3 // 3 ~~~ 所有的位運算都只對整數有效。否運算遇到小數時，也會將小數部分舍去，只保留整數部分。所以，對一個小數連續進行兩次否運算，能達到取整效果。 ~~~ ~~2.9 // 2 ~~~ 使用否運算取整，是所有取整方法中最快的一種。 對字符串進行否運算，JavaScript引擎會先調用Number函數，將字符串轉為數值。 ~~~ // 以下例子相當于~Number('011') ~'011' // -12 ~'42 cats' // -1 ~'0xcafebabe' // 889275713 ~'deadbeef' // -1 // 以下例子相當于~~Number('011') ~~'011'; // 11 ~~'42 cats'; // 0 ~~'0xcafebabe'; // -889275714 ~~'deadbeef'; // 0 ~~~ Number函數將字符串轉為數值的規則，參見《數據的類型轉換》一節。否運算對特殊數值的處理是：超出32位的整數將會被截去超出的位數，NaN和Infinity轉為0。 ### 異或運算 “異或運算”在兩個二進制位不同時返回1，相同時返回0。 ~~~ 0^3 // 3 ~~~ 上面表達式中，0的二進制形式是00，3的二進制形式是11，它們每一個二進制位都不同，所以得到11（即3）。 “異或運算”有一個特殊運用，連續對兩個數a和b進行三次異或運算，a?=b, b?=a, a?=b，可以互換它們的值（詳見[維基百科](http://en.wikipedia.org/wiki/XOR_swap_algorithm)）。這意味著，使用“異或運算”可以在不引入臨時變量的前提下，互換兩個變量的值。 ~~~ var a = 10; var b = 99; a^=b, b^=a, a^=b; a // 99 b // 10 ~~~ 這是互換兩個變量的值的最快方法。 異或運算也可以用來取整。 ~~~ 12.9^0 // 12 ~~~ ### 左移運算符（<<） 左移運算符表示將一個數的二進制形式向前移動，尾部補0。 ~~~ 4 << 1 // 8 // 因為4的二進制形式為100，左移一位為1000（即十進制的8） -4 << 1 // -8 ~~~ 上面代碼中，-4左移一位之所以得到-8，是因為-4的二進制形式是11111111111111111111111111111100，左移一位后得到11111111111111111111111111111000，該數轉為十進制（減去1后取反，再加上負號）即為-8。 如果左移0位，就相當于取整，對于正數和負數都有效。 ~~~ 13.5 << 0 // 13 -13.5 << 0 // -13 ~~~ 左移運算符用于二進制數值非常方便。 ~~~ var color = {r: 186, g: 218, b: 85}; // RGB to HEX var rgb2hex = function(r, g, b) { return '#' + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).substr(1); } rgb2hex(color.r,color.g,color.b) // "#bada55" ~~~ 上面代碼使用左移運算符，將顏色的RGB值轉為HEX值。 ### 右移運算符（>>） 右移運算符表示將一個數的二進制形式向右移動，頭部補上最左位的值，即整數補0，負數補1。 ~~~ 4 >> 1 // 2 /* // 因為4的二進制形式為00000000000000000000000000000100， // 右移一位得到00000000000000000000000000000010， // 即為十進制的2 */ -4 >> 1 // -2 /* // 因為-4的二進制形式為11111111111111111111111111111100， // 右移一位，頭部補1，得到11111111111111111111111111111110, // 即為十進制的-2 */ ~~~ 右移運算可以模擬2的整除運算。 ~~~ 5 >> 1 // 相當于 5 / 2 = 2 21 >> 2 // 相當于 21 / 4 = 5 21 >> 3 // 相當于 21 / 8 = 2 21 >> 4 // 相當于 21 / 16 = 1 ~~~ ### 帶符號位的右移運算符（>>>） 該運算符表示將一個數的二進制形式向右移動，不管正數或負數，頭部一律補0。所以，該運算總是得到正值，這就是它的名稱“帶符號位的右移”的涵義。對于正數，該運算的結果與右移運算符（>>）完全一致，區別主要在于負數。 ~~~ 4 >>> 1 // 2 -4 >>> 1 // 2147483646 /* // 因為-4的二進制形式為11111111111111111111111111111100， // 帶符號位的右移一位，得到01111111111111111111111111111110， // 即為十進制的2147483646。 */ ~~~ ### 開關作用 位運算符可以用作設置對象屬性的開關。 假定某個對象有四個開關，每個開關都是一個變量，取值為2的整數次冪。 ~~~ var FLAG_A = 1; // 0001 var FLAG_B = 2; // 0010 var FLAG_C = 4; // 0100 var FLAG_D = 8; // 1000 ~~~ 上面代碼設置A、B、C、D四個開關，每個開關分別占有1個二進制位。 現在假設需要打開ABD三個開關，我們可以構造一個掩碼變量。 ~~~ var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 ~~~ 上面代碼對ABD三個變量進行“或運算”，得到掩碼值為二進制的1011。 有了掩碼，就可以用“與運算”檢驗當前設置是否與開關設置一致。 ~~~ if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true // ... } ~~~ 上面代碼表示，如果當前設置與掩碼一致，則返回true，否則返回false。 “或運算”可以將當前設置改成開關設置。 ~~~ flags |= mask; ~~~ “與運算”可以將當前設置中凡是與開關設置不一樣的項，全部關閉。 ~~~ flags &= mask; ~~~ “異或運算”可以切換（toggle）當前設置。 ~~~ flags = flags ^ mask; ~~~ “否運算”可以翻轉當前設置。 ~~~ flags = ~flags; ~~~ ## 其他運算符 ### 圓括號運算符 在JavaScript中，圓括號是一種運算符，它有兩種用法：如果把表達式放在圓括號之中，作用是求值；如果跟在函數的后面，作用是調用函數。 把表達式放在圓括號之中，將返回表達式的值。 ~~~ (1) // 1 ('a') // a (1+2) // 3 ~~~ 把對象放在圓括號之中，則會返回對象的值，即對象本身。 ~~~ var o = {p:1}; (o) // Object {p: 1} ~~~ 將函數放在圓括號中，會返回函數本身。如果圓括號緊跟在函數的后面，就表示調用函數，即對函數求值。 ~~~ function f(){return 1;} (f) // function f(){return 1;} f() // 1 ~~~ 上面的代碼先定義了一個函數，然后依次將函數放在圓括號之中、將圓括號跟在函數后面，得到的結果是不一樣的。 由于圓括號的作用是求值，如果將語句放在圓括號之中，就會報錯，因為語句沒有返回值。 ~~~ (var a =1) // SyntaxError: Unexpected token var ~~~ ### void運算符 void運算符的作用是執行一個表達式，然后返回undefined。 ~~~ void 0 // undefined void (0) // undefined ~~~ 上面是void運算符的兩種寫法，都正確。建議采用后一種形式，即總是使用括號。因為void運算符的優先性很高，如果不使用括號，容易造成錯誤的結果。比如，void 4+7 實際上等同于 (void 4) +7 。 下面是void運算符的一個例子。 ~~~ var x = 3; void (x = 5) //undefined x // 5 ~~~ 這個運算符主要是用于書簽工具（bookmarklet）或者用于在超級鏈接中插入代碼，目的是返回undefined可以防止網頁跳轉。 ~~~ javascript:void window.open("http://example.com/") ~~~ 比如，下面是常用于網頁鏈接的觸發鼠標點擊事件的寫法。 ~~~ <a href="#" onclick="f();">文字</a> ~~~ 上面代碼有一個問題，函數f必須返回false，或者onclick事件必須返回false，否則會引起瀏覽器跳轉到另一個頁面。 ~~~ function f(){ // some code return false; } ~~~ 或者寫成 ~~~ <a href="#" onclick="f();return false;">文字</a> ~~~ void運算符可以取代上面兩種寫法。 ~~~ <a href="javascript:void(0)" onclick="f();">文字</a> ~~~ ### 逗號運算符 逗號運算符用于對兩個表達式求值，并返回后一個表達式的值。 ~~~ "a", "b" // "b" var x = 0; var y = (x++, 10); x // 1 y // 10 ~~~ ## 運算順序 （1）運算符的優先級 JavaScript各種運算符的優先級別（Operator Precedence）是不一樣的。優先級高的運算符先執行，優先級低的運算符后執行。 ~~~ 4+5*6 // 34 ~~~ 上面的代碼中，乘法運算符（*）的優先性高于加法運算符（+），所以先執行乘法，再執行加法，相當于下面這樣。 ~~~ 4+(5*6) // 34 ~~~ （2）圓括號的作用 圓括號可以用來提高運算的優先級，即圓括號中的運算符會第一個運算。 ~~~ (4+5)*6 // 54 ~~~ 上面代碼中，由于使用了圓括號，加法會先于乘法執行。 由于運算符的優先級別十分繁雜，且都是來自硬性規定，所以本書不打算列出具體的規則，只是建議讀者總是使用圓括號，保證運算順序清晰可讀，這對代碼的維護和除錯至關重要。 ~~~ 5 + 2 * 4 / 2 % 3 + 10 - 3 total = 5; total *= 2 + 3 ~~~ 上面代碼的運算順序，就不容易一眼看出來，容易導致錯誤，應該加上圓括號幫助閱讀。 （3）左結合與右結合 對于優先級別相同的運算符，大多數情況，計算順序總是從左到右，這叫做運算符的“左結合”（left-to-right associativity），即從左邊開始計算。 ~~~ x + y + z ~~~ 上面代碼先計算最左邊的x與y的和，然后再計算與z的和。 但是少數運算符的計算順序是從右到左，即從右邊開始計算，這叫做運算符的“右結合”（right-to-left associativity）。其中，最主要的是賦值運算符（=）和三元條件運算符（?:）。 ~~~ w = x = y = z; q = a?b:c?d:e?f:g; ~~~ 上面代碼的運算結果，相當于下面的樣子。 ~~~ w = (x = (y = z)); q = a?b:(c?d:(e?f:g)); ~~~ ## 參考鏈接 * Michal Budzynski,?[JavaScript: The less known parts. Bitwise Operators](http://michalbe.blogspot.co.uk/2013/03/javascript-less-known-parts-bitwise.html) * Axel Rauschmayer,?[Basic JavaScript for the impatient programmer](http://www.2ality.com/2013/06/basic-javascript.html) * Mozilla Developer Network,?[Bitwise Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators)