位運算在 JavaScript 中常被當成奇技淫巧,但背後的規則其實很嚴謹。理解它,既能寫出高效能的程式,也能避開那些難以察覺的精度陷阱。
JavaScript 進行位運算時使用 32 位元二進位整數,且整數一律帶符號:最高位 0 為正、1 為負。因此可表達的範圍是:
-Math.pow(2,31) ~ Math.pow(2,31)-1 // -2147483648 ~ 2147483647
三個名詞的定義:
原碼:最高位表示正負,其餘 31 位是絕對值的二進位形式。
反碼:正數與原碼相同;負數則符號位不變,其餘 31 位取反(0 變 1、1 變 0)。
補碼:正數與原碼相同;負數為反碼加 1。
有意思的是 0 的情況:+0 的反碼是 32 個 0,三種碼都是 0;-0 的反碼是 32 個 1,加 1 後最高位進位溢出被捨棄,補碼回到 32 個 0。所以正負 0 的補碼相同。
由負數的補碼反推絕對值:各位(含符號位)取反再加 1 即可。
電腦在處理加減時統一使用補碼,減法被視為「加上一個負數」。補碼的存在就是為了統一加減運算的電路。
原理是 32 位的溢出。對於 32 位元正整數,其模為:
Math.pow(2,32) = 4294967296
32 位正整數最大只能表達 4294967295,達到 4294967296 就要進位到第 33 位,而第 33 位是溢出位會被丟棄,結果只剩 32 個 0。這就跟時鐘的道理一樣:指針走到 12 和走到 0 是同一個位置,錶盤以 12 為模。
因此任何超過 4294967295 的數 M,實際上等同於 M % 4294967296;而負數 -M 可以表示為正數 4294967296 - M——這個正數就是該負數補碼對應的二進位值。負數的補碼加上它的原碼,剛好等於模。
以 -3 為例:
(Array(32).join("0") + (3).toString(2)).slice(-32); // |-3| 的二進位,即原碼
原碼 = 00000000000000000000000000000011
反碼 = 11111111111111111111111111111100 // 符號位為 1,其餘取反
補碼 = 11111111111111111111111111111101 // 反碼加 1
驗證:
補碼 + 原碼 = (反碼 + 1) + 原碼
= (反碼 + 原碼) + 1
= 1 + (32 位全是 1 的二進位數)
= Math.pow(2,32)
= 4294967296 // 正是 32 位的模
這就是「正數減法 → 負數加法 → 補碼加法」的完整鏈路。
因為 JavaScript 的整數預設帶符號,位運算中開發者只能使用 31 位,最高位被保留作為符號位,無法直接存取。
位運算只發生在整數上,非整數運算元會先被無條件捨去(向零取整)。為了避免存取符號位,JavaScript 在呈現負數的二進位時,會轉為「符號 + 絕對值的二進位」:
(-123).toString(2); // "-1111011"
一元運算,1 變 0、0 變 1。
~123; // -124
驗證過程:正數取反後符號位變負,結果必為負數。依 Math.pow(2,32) - M 表示 -M 的規則:
parseInt((Array(32).join(0) + (123).toString(2)).slice(-32)
.replace(/\d/g, function(v) { return (v * 1 + 1) % 2; }), 2) - Math.pow(2,32)
// -124
對整數 M 按位取反的通用公式:
((-1 * M - 1) + Math.pow(2,32)) % Math.pow(2,32)
對應位皆為 1 才回傳 1。
234 & 106 "00000000000000000000000001111011" "00000000000000000000000011101010" --------------------------------- "00000000000000000000000001101010" // 106
對應位只要有一個 1 就回傳 1。
234 | 106 "00000000000000000000000001111011" "00000000000000000000000011101010" --------------------------------- "00000000000000000000000011111011" // 251
對應位相異才回傳 1。
234 ^ 106 "00000000000000000000000001111011" "00000000000000000000000011101010" --------------------------------- "00000000000000000000000010010001" // 145
異或有幾個優雅的性質:
a ^ a = 0 a ^ b = b ^ a a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c a ^ b ^ a = b d = a ^ b ^ c ⇒ a = d ^ b ^ c // 這條被用在部分加密演算法中
利用這些性質,可以在不溢出的前提下交換兩個變數:
a = [b, b = a][0]; // 或者 a = a ^ b; b = a ^ b; a = a ^ b;
取 1、2、4、8、16……這類「二進位中只有一位是 1」的值,它們任意組合的異或結果都不會出現同位皆為 1 的情況,且結果唯一可反推。
00000001 00000010 00000100 00001000 00010000 1 ^ 2 ^ 4 = 7 // "00000111"
知道結果是 7,就知道它由 1、2、4 組合而成。要設定含多個狀態的參數時,用按位或運算組裝即可。PHP 中圖片型別常數、錯誤等級常數都是這個套路。
左移 <<:所有位向左移動,符號位不動,高位溢出丟棄,低位補 0。不溢出時效果等同乘以 2。
右移 >>:所有位向右移動,符號位不動,高位補 0,低位丟棄。效果等同除以 2 後無條件捨去。
無符號右移 >>>:符號位隨其他位一起移動,被當成數值看待,結果一律是 32 位無符號整數。因此負數的無符號右移會產生正整數。這是唯一能操作符號位的運算子。
-123 >>> 1; // 2147483586
1. 運算元必須是整數,非可用的整數一律取 0:
~NaN; // 執行 ~0,結果 -1
~'x'; // -1
'hello' | 0; // 0
({}) | 0; // 0
2. 位移數不能超過 31,超過時會先對 32 取模再移位:
123 >> 32; // 實際是 123 >> 0 123 >> 33; // 實際是 123 >> 1
3. 精度溢出的隱形陷阱。這是實務上最容易出事的。32 位帶符號整數範圍是 -2147483648 ~ 2147483647,但 JavaScript 的 Number 是 64 位雙精度浮點。一個超過 2147483647 的整數參與位運算時,其二進位會被截斷為 32 位,若第 32 位是 1,就會被解讀為負數(補碼形式):
2147483648 >> 0; // -2147483648 4294967296 >> 0; // 0 4294967295 >> 0; // -1 4294967297 >> 0; // 1
這正是為什麼「用 x | 0 取整」這個常見技巧不能用在可能超過 21 億的數字上。處理大數請用 Math.floor(),或者直接改用 BigInt。
位運算的本質是「在 32 位整數的模運算系統中操作」。理解補碼與模的概念,就能預測任何運算結果;理解符號位與 32 位上限的限制,就能避開絕大多數的精度陷阱。它最適合用於效能敏感的位元遮罩、狀態組合與快速取整——前提是確定數值不越界。