介紹 JavaScript 中的運算子 (Operators) 的用法，包含種類、優先順序、算術運算子 (Arithmetic Operator)、指派運算子 (Assignment Operator)、位元運算子 (Bitwise Operator) 和比較運算子 (Comparison Operator)。

簡介

運算式

運算式 (Expression) 或稱表達式，能夠讓直譯器理解並執行的程式片段都可以稱作運算式， 例如任何的實字或變數名稱，以下為一些運算式：

1
2
3
4
123
i
123 + i
x = 123 + i

以下不是運算式：

1
2
123 +
x = 123 +

種類

運算式中可透過提供一些數值給運算子 (Operator，或運算符) 進行運算，進而得到一個運算結果，可以想成類似函式的回傳。另外被運算的數值稱為運算元 (Operand)。

依據運算元的個數，運算子可以分為三種：

  1. 一元運算子，只有一個運算元，例如：!, ++ 等。
  2. 二元運算子，包含兩個運算元，大部分都屬於這類。
  3. 三元運算子，包含三個運算元，只有 ? : 運算子屬於此類。

而依據性質，可以分為：

  1. 算術運算子 (Arithmetic Operator)
  2. 指派運算子 (Assignment Operator)
  3. 位元運算子 (Bitwise Operator)
  4. 比較運算子 (Comparison Operator)
  5. 邏輯運算子 (Logical Operator)
  6. 字串運算子 (String Operator)
  7. 特殊運算子 (Special Operator)

優先順序

結合律運算子
右new
左[] () .
右++ – ~ - + (正負號) ! delete typeof void
左* / %
左+ - (加減, 字串連接)
左<< >> >>>
左< <= > >= <>
左== != === !==
左&
左^
左|
左&&
左||
右? :
右= += -= *= /= %= &= |= ^= <<= >>= >>>=
左,

結合律左右的解釋範例如下：

1
2
3
4
5
6
7
console.log(1 + 2 + '3');  // 33
console.log(1 + '2' + 3);  // 123

// 結合律: 右
var a = 1;
var b = 2;
a = b += 3;         // b = 5, a = 5

算術運算子

算術運算子 (Arithmetic Operator) 就如同數學的四則運算一般，包含以下運算子：

範例名稱說明
+a正號實際上無作用
-a負號將 a 正負變號
a + b加法a 和 b的總和
a - b減法a 減去 b
a * b乘法a 乘上 b
a / b除法a 除以 b
a % b取餘數a 除以b的餘數 (餘數的正負號與 a 相同)
++a前置增值a 先 +1，再回傳
a++後置增值a 先回傳，再 +1
–a前置減值a 先 -1，再回傳
a–後置減值a 先回傳，再 -1

指派運算子

指派運算子 (Assignment Operator) 符號是 (=)，你可能會把它想成數學的等於，但實際上不能這樣想，正確的意思是：將右邊的結果放入左邊。

指派運算子會將指派結果回傳，也就是指派的內容本身，又因為結合律為右，所以可以將指派的回傳結果指派給下個變數，例如

1
2
3
4
var x, y, z;
console.log(y = 1);    // 1
x = y = z = 2;
console.log(x, y, z);  // 2, 2, 2

另外也有具有運算的指派，包含以下運算子：

範例說明
a += ba = a + b
a -= ba = a - b
a *= ba = a * b
a /= ba = a / b
a %= ba = a % b
a <<= ba = a << b
a >>= ba = a >> b
a &= ba = a & b
a |= ba = a | b
a ^= ba = a ^ b

位元運算子

位元運算子 (Bitwise Operator) 能夠對整數的位元進行運算，包含以下運算子：

範例名稱說明
a & b交集 (And)a 和 b 的位元皆為 1 的部份為 1
a | b聯集 (Or)a 或 b 的位元其中一方為 1 的部份為 1
a ^ b互斥 (Xor)a 和 b 的位元只有其中一方為 1 的部份為 1
~ a補數 (Not)a 為 1 的 部份為 0，為 0 的部份為 1
a << b左移a 往左移動 b 個位元 (意同 a 乘以 2 的 b 次方)
a >> b帶正負號右移a 往右移動 b 個位元，並保留原始正負號 (意同 a 除以 2 的 b 次方之整數)
a >>> b補 0 右移a 往右移動 b 個位元，無視正負號，左邊的位元一律補 0

JavaScript 中處理位元運算時，變數一律視為 32 位元的數值來處理，當位移數超過 32 位元時，會取 32 的餘數來進行運算，以下是一些範例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
function toBitsString(num) {
  var str = '';
  while (num) {
    str = (num & 1) + str;
    num = num >>> 1
  }
  return str;
}

function toBits(num) {
  var str = toBitsString(num)
  for (var i = str.length; i < 8; ++i) {
    str = '0' + str;
  }
  return str.slice(-8);
}
var a = 55;
var b = 66;

console.log(toBits(a));        //   00110111
console.log(toBits(b));        // & 01000010
                               //-----------
console.log(toBits(a & b));    //   00000010 : 2

                               //   00110111
                               // | 01000010
                               //-----------
console.log(toBits(a | b));    //   01110111 : 119

                               //   00110111
                               // ^ 01000010
                               //-----------
console.log(toBits(a ^ b));    //   01110101 : 117

                               // ~ 00110111
                               //------------
console.log(toBits(~a));       //   11001000 : -56

                               // 00110111 << 2
                               //------------
console.log(toBits(a << 2));   // 11011100 : 220

                               // 00110111 >> 33
                               //------------
console.log(toBits(a >> 33));  // 00011011 : 27

console.log(-4 >> 1);  // -2
console.log(-4 >>> 1); // 2147483646

JavaScript 的數字類別的 toString 函式能夠將數字依據指定的進位制輸出字串，但是它是把他視為具有正負號的數字處理，而不是作為位元組處理，所以必須自行實作轉換：

1
2
3
4
var a = -56;
console.log(a.toString(2));   // -111000
console.log(a.toString(16));  // -38
console.log(toBitsString(a)); // 11111111111111111111111111001000

比較運算子 (Comparison Operator)

比較運算子 (Comparison Operator) 可以比較兩個值，並將結果以布林回傳，包含以下運算子：

範例名稱說明
a == b相等如果 a 和 b 的值相等則為 true
a === b完全相等如果 a 和 b 的值與型別都相等則為 true，物件、陣列和函式必須是同一個物件才為 true
a != b不相等如果 a 和 b 的值不相等則為 true
a !== b不完全相等如果 a 和 b 的值或型別不相等則為 true
a < b小於如果 a 小於 b 則為 true
a > b大於如果 a 大於 b 則為 true
a <= b小於等於如果 a 小於等於 b 則為 true
a >= b大於等於如果 a 大於等於 b 則為 true

只有以下情形完全相等才為 true：

  1. 兩者皆是非NaN數字型別且數值相等。
  2. 兩者皆是字串型別且內容相等。
  3. 兩者皆是布林型別且數值相等。
  4. 兩者都指向同一物件、陣列或函式。
  5. 兩者皆是 null。
  6. 兩者皆是 undefined。

進行相等運算比較時，會根據以下的規則來做處理：

  1. undefined 或 null 只和 undefined 或 null 相等。
  2. 其他情況依據非相等運算規則處理。

進行非相等運算比較時，會根據以下的規則來做處理：

  1. 運算元包含 undefined 和 NaN 則為 false。
  2. 兩者皆為字串，則以字串比較。(Unnicode編碼比較)
  3. 空陣列和字串比較，空陣列優先轉為字串比較。
  4. 一方為數字或能轉換為數字，則以數字比較。(另一方無法轉換則為 false)
  5. 其他情況轉換為字串，以字串比較。
  6. 若不能轉換成數字或字串，則為 false。

一些範例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
console.log(10 == '1e1');           // true, 數字比較
console.log('b' > 'a');             // true
console.log('' == 0);               // true, 數字比較
console.log(false == null);         // false, undefined 或 null 只和 undefined 或 null 相等
console.log(undefined == null);     // true
console.log(2 > true && true > 0);  // true, 數字比較, true -> 1
console.log(1 > null && null > -1); // true, 數字比較, null -> 0
console.log(false > -1);            // true, 數字比較
console.log([] > -1);               // true, 數字比較, 空陣列轉為 0
console.log(false > '-1');          // true, 數字比較
console.log([] > '-1');             // false, 字串比較 !!

function A() {
}

A.prototype.toString = function () {
  return 'A';
};

var a = new A();
var s = {}; // [object Object]

console.log(a < s);       // true, 字串比較 'A' < '[object Object]'
console.log(a == 'A');    // true
console.log(s > '\xff');  // false

var b = [55];
var c = [66];
var d = [55,66];
console.log(b < c);         // true, 字串比較 '55' < '66'
console.log(b == '55');     // true
console.log(d == '55,66');  // true

延伸閱讀

下一篇 JavaScript 教學 - 變數 (Variables)
下一篇 JavaScript 教學 - 運算子 (Operators) - 下