運算子有哪些：深入解析程式設計中的各種運算子

Byadmin

「運算子有哪些？」這個問題，相信許多剛踏入程式設計領域的朋友都會碰上，就像我剛開始接觸程式時，看到那些符號，腦袋裡也是一團漿糊！到底這些「+」、「-」、「*」、「/」等等，在程式碼裡扮演什麼角色？它們又有哪些不一樣的功能呢？今天，就讓我們一起來深入了解一下，程式設計中各式各樣的「運算子」吧！

程式設計中的運算子：不只是加減乘除

簡單來說，運算子（Operator）就是用來對一個或多個「運算元」（Operand）執行特定操作的符號。運算元就是我們常說的變數、常數、值等等。就像我們在數學課上學到的，2 + 3，其中的「+」就是運算子，「2」和「3」就是運算元。在程式設計的世界裡，運算子的種類可就豐富多了，它們是構成程式邏輯的基石，絕對是不可或缺的幫手！

這次，我們將會把運算子們「分門別類」，並透過具體的例子，讓大家對它們的用法有更清晰的認識。我認為，理解運算子的核心在於「它們能做什麼」以及「如何正確使用」。

算術運算子：最基礎的數學助手

這絕對是大家最熟悉的一群運算子了！它們就像是程式碼裡的計算機，負責處理各種數值運算。雖然看起來很基本，但如果使用不當，也會造成意想不到的錯誤喔！

  • 加法運算子 (`+`)：用於兩個數值的加法。例如：`let sum = 10 + 5; // sum 的值為 15`。
  • 減法運算子 (`-`)：用於兩個數值的減法。例如：`let difference = 10 – 5; // difference 的值為 5`。
  • 乘法運算子 (`*`)：用於兩個數值的乘法。例如：`let product = 10 * 5; // product 的值為 50`。
  • 除法運算子 (`/`)：用於兩個數值的除法。例如：`let quotient = 10 / 5; // quotient 的值為 2`。
  • 取餘數運算子 (`%`)：用於計算除法的餘數。這在判斷奇偶數、循環處理等方面非常有用。例如：`let remainder = 10 % 3; // remainder 的值為 1`。
  • 遞增運算子 (`++`)：將變數的值加 1。有前置遞增（先加 1 再使用值）和後置遞增（先使用值再加 1）之分。例如：

    let a = 5; a++; console.log(a); // 輸出 6

    let b = 5; console.log(b++); // 輸出 5，然後 b 變為 6

  • 遞減運算子 (`–`)：將變數的值減 1。同樣有前置和後置之分。例如：

    let c = 5; c--; console.log(c); // 輸出 4

    let d = 5; console.log(d--); // 輸出 5，然後 d 變為 4

關於取餘數運算子的實用小技巧

我常常會在判斷一個數字是不是偶數的時候用到取餘數運算子。如果一個數字除以 2 的餘數是 0，那它就是偶數，否則就是奇數。簡單吧！例如：

function isEven(number) {
return number % 2 === 0;
}
console.log(isEven(4)); // 輸出 true
console.log(isEven(7)); // 輸出 false

賦值運算子：讓變數值「聽話」

賦值運算子負責將一個值「塞」進變數裡。最常見的當然是「=」，但其實還有很多複合的賦值運算子，可以讓我們的程式碼更簡潔、更有效率。

  • 基本賦值運算子 (`=`)：將右側的值賦給左側的變數。例如：`let age = 30;`。
  • 加法賦值運算子 (`+=`)：將左側變數與右側值相加，再將結果賦給左側變數。這相當於 `variable = variable + value`。例如：`let count = 10; count += 5; // count 的值變為 15`。
  • 減法賦值運算子 (`-=`)：類似於 `+=`，但執行的是減法。例如：`let score = 100; score -= 20; // score 的值變為 80`。
  • 乘法賦值運算子 (`*=`)：類似於 `+=`，但執行的是乘法。例如：`let price = 10; price *= 2; // price 的值變為 20`。
  • 除法賦值運算子 (`/=`)：類似於 `+=`，但執行的是除法。例如：`let quantity = 50; quantity /= 5; // quantity 的值變為 10`。
  • 取餘數賦值運算子 (`%=`)：類似於 `+=`，但執行的是取餘數。例如：`let total = 100; total %= 7; // total 的值變為 2`。

這些複合賦值運算子，對於減少程式碼的重複性非常有用。試想一下，如果你需要不斷地在一個變數上做加法，使用 `+=` 會比寫 `variable = variable + value` 多次來得方便多了！

比較運算子：判斷真假的守門員

比較運算子是用來比較兩個運算元，並根據比較的結果返回一個布林值（`true` 或 `false`）。這在條件判斷（例如 `if` 語句）中至關重要！

  • 等於運算子 (`==`)：判斷兩個運算元的值是否相等。請注意，這個運算子會進行型別轉換！ 例如：`5 == “5” // 輸出 true`。
  • 嚴格等於運算子 (`===`)：判斷兩個運算元的值和型別是否都相等。這個運算子不會進行型別轉換，是更安全的選擇。 例如：`5 === “5” // 輸出 false`。
  • 不等於運算子 (`!=`)：判斷兩個運算元的值是否不相等。同樣會進行型別轉換。例如：`5 != “10” // 輸出 true`。
  • 嚴格不等於運算子 (`!==`)：判斷兩個運算元的值或型別是否至少有一個不相等。不會進行型別轉換。 例如：`5 !== “5” // 輸出 true`。
  • 大於運算子 (`>`)：判斷左側運算元是否大於右側運算元。
  • 小於運算子 (`<`)：判斷左側運算元是否小於右側運算元。
  • 大於或等於運算子 (`>=`)：判斷左側運算元是否大於或等於右側運算元。
  • 小於或等於運算子 (`<=`)：判斷左側運算元是否小於或等於右側運算元。

嚴格等於 vs. 等於：一個容易犯錯的陷阱

這是我在教學時常常強調的一點。== 和 === 的差別，看似微小，卻可能導致嚴重的 bug。例如，當我們從使用者輸入中取得數值時，它通常會以字串的形式被讀取。如果我們直接使用 == 進行比較，可能會得到意想不到的結果。例如：

let userInput = "10";
if (userInput == 10) {
console.log("數值相等！"); // 這行會執行
}
if (userInput === 10) {
console.log("數值和型別都相等！"); // 這行不會執行
}

因此，在大多數情況下，我都會建議大家優先使用嚴格相等運算子 ===，這樣能避免許多潛在的型別錯誤。除非你明確知道自己需要型別轉換，否則就乖乖用 === 吧！

邏輯運算子：連結判斷的橋梁

邏輯運算子用於組合或修改布林表達式，它們是構建複雜條件判斷的關鍵。就像是邏輯世界的「與」、「或」、「非」。

  • 邏輯 AND 運算子 (`&&`)：如果兩側的運算元都為 `true`，則結果為 `true`；否則為 `false`。它具有「短路」特性：如果左側運算元為 `false`，則右側運算元將不會被評估。
  • 邏輯 OR 運算子 (`||`)：只要兩側的運算元有一個為 `true`，則結果為 `true`；只有兩側都為 `false`，結果才為 `false`。它也具有「短路」特性：如果左側運算元為 `true`，則右側運算元將不會被評估。
  • 邏輯 NOT 運算子 (`!`)：對運算元進行邏輯反轉。如果運算元為 `true`，結果為 `false`；如果為 `false`，結果為 `true`。

邏輯運算子就像是程式碼的指揮官，它們讓我們能夠精確地控制程式的流程。舉個例子，你想確保一個使用者必須同時滿足「已登入」且「是會員」，就可以用 &&：

let isLoggedIn = true;
let isMember = true;
if (isLoggedIn && isMember) {
console.log("歡迎，會員！");
}

而 || 則可以用於「或者」的判斷，例如，使用者是管理者「或者」是 VIP，都可以享有特殊權限：

let isAdmin = false;
let isVip = true;
if (isAdmin || isVip) {
console.log("您享有特殊權限！");
}

位元運算子：直接操作二進位

位元運算子直接對數字的二進位表示進行操作。這在某些底層操作、效能優化或特定演算法中會用到，對大多數日常開發來說，可能接觸較少，但了解它們的原理能開闊視野。

  • 位元 AND (`&`)：對兩個數字的每一位進行 AND 運算。
  • 位元 OR (`|`)：對兩個數字的每一位進行 OR 運算。
  • 位元 XOR (`^`)：對兩個數字的每一位進行 XOR 運算。
  • 位元 NOT (`~`)：對數字的每一位進行 NOT 運算。
  • 左移 (`<<`)：將數字的二進位表示向左移動指定的位数，右側補 0。相當於乘以 2 的 n 次方。
  • 右移 (`>>`)：將數字的二進位表示向右移動指定的位数。
  • 無符號右移 (`>>>`)：類似於右移，但無論符號位如何，右側都補 0。

我個人在使用位元運算子的機會比較少，但有一次在處理圖像像素數據時，就需要用到位元運算子來快速提取或設定 RGB 的各個顏色分量。它們的速度非常快，因為是直接在硬體層面操作。

其他常見運算子

除了上述幾類，還有一些在特定情境下非常重要的運算子：

  • 條件 (三元) 運算子 (`?:`)：這是一個簡化的 `if-else` 語句。語法是 `condition ? value_if_true : value_if_false`。例如：`let status = (age >= 18) ? “成年” : “未成年”;`。這能讓程式碼更緊湊。
  • 成員運算子 (`.` 和 `[]`)：用於訪問物件的屬性或陣列的元素。例如：`object.propertyName` 或 `array[index]`。
  • 類型運算子 (`typeof`, `instanceof`)：用於檢查變數的資料型別。`typeof` 返回字串，如 “number”, “string”, “boolean” 等。`instanceof` 則檢查一個物件是否是某個類別的實例。
  • 逗號運算子 (`,`)：從左到右依序執行各個運算元，並返回最後一個運算元的結果。主要用於 `for` 迴圈中，一次性更新多個變數。
  • 刪除運算子 (`delete`)：用於刪除物件的屬性或陣列的元素。
  • 屬性存取運算子 (`?.`)：可選鏈運算子，用於安全地存取巢狀物件屬性，避免因中間屬性為 `null` 或 `undefined` 而報錯。

可選鏈運算子 (`?.`) 的妙用

這個運算子對我來說，簡直是救星！以前處理複雜的 JSON 數據時，常常需要一層一層地檢查屬性是否存在，程式碼寫起來又臭又長。有了 `?.`，這一切都變得輕鬆多了。例如：

let user = {
name: "小明",
address: {
city: "台北"
}
};
console.log(user.address?.city); // 輸出 "台北"
console.log(user.profile?.age); // 輸出 undefined，不會報錯！

這比以前寫 if (user && user.address && user.address.city) { ... } 方便太多了！

運算子優先順序：程式碼執行的隱形規則

當一個表達式中包含多個運算子時，它們的執行順序是由「運算子優先順序」決定的。這就像數學中的先乘除後加減一樣，程式語言也有類似的規則。如果我們不了解優先順序，可能會得到錯誤的結果。例如：

let result = 2 + 3 * 4; // 這裡會先計算 3 * 4，再加 2，所以 result 是 14。

為了確保程式碼的清晰和正確，如果有多個運算子，強烈建議使用括號 `()` 來明確指定運算順序。這不僅能避免誤解，也能讓程式碼更容易閱讀。

運算子結合性：同級運算子的處理

當一個表達式中出現多個優先順序相同的運算子時，就輪到「運算子結合性」登場了。大多數運算子是「左結合」，也就是從左到右執行。例如 `a – b – c` 會被理解為 `(a – b) – c`。而有些運算子是「右結合」，例如賦值運算子 `a = b = c` 會被理解為 `a = (b = c)`。了解結合性有助於更精確地理解複雜的表達式。

常見問題與專業解答

在學習運算子的過程中，大家可能還會遇到一些疑惑。這裡我整理了一些常見問題，並提供詳細的解答。

Q1：我在比較數字和字串時，為什麼會出現奇怪的結果？

這個問題通常跟「型別轉換」有關，特別是在使用 == (等於運算子) 的時候。當你用 == 比較不同型別的值時，語言解釋器會嘗試將其中一個或兩個值轉換成相同的型別，然後再進行比較。這可能會導致一些出乎意料的結果。例如：

'5' == 5 // true，因為字串 '5' 被轉換成了數字 5。
0 == false // true，因為 false 在轉換成數字時是 0。
null == undefined // true，這是 JavaScript 的一個特殊規則。

專業建議： 為了避免這種潛在的混亂和錯誤，強烈建議在比較時使用「嚴格等於運算子」=== 和「嚴格不等於運算子」!==。它們不會進行型別轉換，只會比較值和型別是否完全一致。例如：

'5' === 5 // false
0 === false // false
null === undefined // false

使用 === 和 !== 可以讓你的程式碼更具可預測性，減少許多難以追蹤的 bug。

Q2：什麼時候應該使用複合賦值運算子，而不是單獨的運算子？

複合賦值運算子，如 +=, -=, *= 等，本身並沒有增加額外的功能，它們只是提供了一種更簡潔的寫法。例如，`x += 5` 就等同於 `x = x + 5`。那麼，為什麼要使用它們呢？

主要原因有二：

  1. 程式碼簡潔性： 複合賦值運算子可以讓你的程式碼更短，更容易閱讀。對於需要重複對同一個變數進行算術運算的場景，這尤其明顯。
  2. 效能考量 (在某些語言中)： 在某些情況下，編譯器或直譯器可能會對複合賦值運算子進行額外的優化，使其效能略優於單獨的運算子。儘管在現代 JavaScript 等語言中，這種效能差異可能非常微小，但在一些效能敏感的應用程式中，這點也值得考慮。

總結來說： 如果你的目的是對一個變數進行算術運算並將結果重新賦值給它，那麼使用複合賦值運算子通常是更佳的選擇，因為它更簡潔且意圖更明確。例如，在累加一個陣列的所有元素時：

let total = 0;
for (let i = 0; i < numbers.length; i++) { total += numbers[i]; // 比 total = total + numbers[i]; 更簡潔 }

Q3：邏輯運算子中的「短路」是什麼意思？

「短路」是邏輯運算子 && (AND) 和 || (OR) 的一個重要特性。它的意思是，當我們透過這些運算子評估一個表達式時，並非總是會對左右兩側的運算元都進行計算。

對於 && (AND)：

  • 如果左側的運算元結果是 `false`，那麼整個表達式的值就一定是 `false`，無論右側是什麼。因此，右側的運算元就不會被計算。
  • 如果左側的運算元結果是 `true`，那麼整個表達式的結果就取決於右側。此時，右側的運算元就會被計算。

對於 || (OR)：

  • 如果左側的運算元結果是 `true`，那麼整個表達式的值就一定是 `true`，無論右側是什麼。因此，右側的運算元就不會被計算。
  • 如果左側的運算元結果是 `false`，那麼整個表達式的結果就取決於右側。此時，右側的運算元就會被計算。

短路機制的實際應用：

這種短路特性非常有用，可以讓我們避免不必要的計算或潛在的錯誤。例如，在檢查一個物件是否存在以及其屬性是否存在時：

// 假設 user 可能不存在
let userName = user && user.name; // 如果 user 是 undefined 或 null，userName 就會是 undefined，不會報錯。

再例如，給一個變數設定預設值：

let color = userSelectedColor || 'defaultColor'; // 如果 userSelectedColor 是 undefined, null, 0, '' 等「假值」，則會使用 'defaultColor'。

理解並善用短路特性，能讓你的程式碼更安全、更有效率。

希望這篇文章能讓你對「運算子有哪些」有更深入、更全面的了解。運算子雖然看似簡單，但它們的組合運用卻能創造出無窮的邏輯變化，是程式設計中不可或缺的基礎！

運算子有哪些