您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

Swift 運算符完整解析:從賦值、算術到邏輯與範圍

編輯:iOS 開發綜合

運算符是程式語言裡最基礎、也最高頻的表達工具。它可以是一個符號,也可以是一段關鍵字,用來檢查、修改或組合數值。最直觀的例子是加法運算符 +,把兩個數字相加寫成 let i = 1 + 2;稍微複雜一點的有邏輯 AND &&,例如 if enteredDoorCode && passedRetinaScan;再不然就是自增運算符 ++i,它其實就是 i = i + 1 的簡寫形式。

Swift 沿用了 C 標準庫中的絕大多數運算符,同時針對它們做了不少安全性增強,目的是把常見的編碼疏漏提前擋在編譯階段。例如賦值運算符 = 不會回傳任何值,這樣就杜絕了把 == 誤寫成 = 卻仍能通過編譯的情況;算術運算符(+、-、*、/、% 等)預設會偵測並拒絕溢位,避免數值超出所屬型別的儲存範圍後產生難以追查的錯誤。如果你確實需要讓溢位發生,可以改用 Swift 提供的溢位運算符來明確表達意圖,這部分會在「溢位運算符」中介紹。

與 C 不同的是,Swift 允許對浮點數取餘數;此外它還提供了兩個範圍運算符 a...b 與 a..<b,作為描述一段連續數值的語法糖,這在 C 裡是沒有的。

本章聚焦於 Swift 的常用運算符;更高階的內容,包括自訂運算符與為自訂型別實作運算符,則留待「進階運算符」中介紹。

基本術語

運算符可以按參與運算的物件數量分成三類:

  • 一元運算符只作用於單一物件,例如 -a。它又可以細分為前置與後置兩種:前置一元運算符寫在物件前面,如 !b;後置一元運算符寫在物件後面,如 i++。
  • 二元運算符作用於兩個物件,並且位於兩者中間,例如 2 + 3。
  • 三元運算符作用於三個物件。與 C 相同,Swift 只提供一個三元運算符,也就是三元條件運算符 a ? b : c。

被運算符作用的那些值稱為運算數(operand)。在運算式 1 + 2 裡,+ 是一個二元運算符,而 1 和 2 分別是它的兩個運算數。

賦值運算符

賦值運算符 a = b 的意義是:用 b 的值去初始化或更新 a。

let b = 10
var a = 5
a = b      // 此時 a 的值為 10

如果右側是一個包含多個元素的 tuple,那些元素可以一次對應地賦給左側的多個常數或變數:

let (x, y) = (1, 2)   // x 等於 1,y 等於 2

與 C、Objective-C 不同,Swift 的賦值運算符並不會把自身當成一個值回傳,所以下面這種寫法是不合法的:

if x = y {
    // 錯誤:x = y 並不會產生任何值
}

這個設計的用意很明確——攔住「把 == 寫成 =」這類低級但常見的錯誤,因為 if x = y 根本無法通過編譯。

算術運算符

Swift 為所有數值型別提供了四則運算:

  • 加法 +、減法 -
  • 乘法 *
  • 除法 /
1 + 2        // 等於 3
5 - 3        // 等於 2
2 * 3        // 等於 6
10.0 / 2.5   // 等於 4.0

和 C、Objective-C 不一樣,Swift 的算術運算符預設不容許值溢位。若你希望在特定情境下允許溢位,可以改用溢位運算符(例如 a &+ b),詳見 Overflow Operators。

加法運算符同樣可以用來拼接字串:

"hello, " + "world"   // 等於 "hello, world"

兩個字元,或一個字元加一個字串,也能組合成新的字串:

let dog: Character = "🐶"
let cow: Character = "🐮"
let dogCow = dog + cow   // dogCow 等於 "🐶🐮"

更多細節可參考 Concatenating Strings and Characters。

取餘運算符

取餘運算符 a % b 會先算出 a 裡包含幾個完整的 b,再回傳剩下來的那部分,也就是餘數。

附註:餘數運算符 % 在其他語言裡常被稱為取模運算符。但在 Swift 中,一旦運算數出現負數,嚴格來說得到的是「餘數」而不是「模數」。

以 9 % 4 為例,先看 9 裡能塞進幾個 4:

9 可以減掉兩個 4,剩下的 1 就是餘數(圖中以橙色標示)。在 Swift 裡寫成:

9 % 4   // 等於 1

要得到 a % b 的結果,% 實際上是在求解下面這個等式,並把餘數作為輸出:

a = (b × some multiplier) + remainder

其中 some multiplier 是 a 中最多能包含幾個 b。把 9 和 4 代入:

9 = (4 × 2) + 1

同樣的方法也適用於負數:

-9 % 4   // 等於 -1

把 -9 和 4 代入公式:

-9 = (4 × -2) + -1

於是餘數為 -1。值得注意的是,b 的負號會被忽略,也就是說 a % b 與 a % -b 的結果完全相同。

浮點數取餘

不同於 C 與 Objective-C,Swift 的餘數運算符也能直接用在浮點數上:

8 % 2.5   // 等於 0.5

這裡 8 除以 2.5 可以整除 3 次,剩下的 0.5 就是餘數。

自增與自減運算符

和 C 一樣,Swift 提供了自增 ++ 與自減 --,作為把數值加一或減一的快捷寫法,你可以用在任何整數或浮點變數上。

var i = 0
++i    // i 現在等於 1

每次寫下 ++i,i 就增加 1,本質上等同 i = i + 1;同理 --i 等同 i = i - 1。

++ 與 -- 既能當前置運算符,也能當後置運算符。++i 和 i++ 都能讓 i 加一,--i 與 i-- 也是。這些運算符都會修改 i,同時回傳一個值;如果你只想讓 i 增減而不在意回傳值,直接忽略它就好。但若你真的要用回傳值,就必須留意前置與後置的差別:

  • 運算符寫在變數前面時,先把變數加一,再回傳新值。
  • 運算符寫在變數後面時,先回傳原值,再把變數加一。
var a = 0
let b = ++a   // a 與 b 現在都等於 1
let c = a++   // a 現在等於 2,但 c 拿到的是自增前的 1

第一句中 let b = ++a,a 在回傳之前就已經加一,所以 a 和 b 都是 1。第二句 let c = a++,a 在回傳之後才加一,因此 c 得到的是舊值 1,接著 a 才變成 2。

實務上的建議是:除非確實需要後置運算符的副作用,否則一律優先用 ++i 與 --i,因為「先修改、再回傳」的行為更符合多數人的直覺。

一元負號運算符

在數值前面加上 -,就是一項一元負號運算:

let three = 3
let minusThree = -three      // minusThree 等於 -3
let plusThree = -minusThree  // plusThree 等於 3,也就是「負的負三」

一元負號緊貼在數值前面書寫,中間不加空格。

一元正號運算符

一元正號 + 什麼都不做,只是原封不動地回傳它作用的數值:

let minusSix = -6
let alsoMinusSix = +minusSix   // alsoMinusSix 等於 -6

實作上它確實沒有實際效果,但當你同時在用一元負號處理負數時,它能讓正數那一側看起來更對稱、更容易讀。

複合賦值運算符

類似 C,Swift 也提供複合賦值運算符,把賦值與另一個運算合併在一起。以加法賦值 += 為例:

var a = 1
a += 2   // a 現在等於 3

a += 2 比 a = a + 2 來得精簡,一次運算就同時完成加法與賦值兩件事。

要注意,複合賦值運算符同樣不回傳值。所以你無法寫出 let b = a += 2 這種程式碼,這點與前面提到的自增、自減運算符不同。

完整的複合賦值運算符清單可以在 Expressions 章節中找到。

比較運算符

Swift 支援所有標準的 C 比較運算符:

  • 相等 a == b
  • 不相等 a != b
  • 大於 a > b
  • 小於 a < b
  • 大於等於 a >= b
  • 小於等於 a <= b

Swift 另外還提供兩個「恆等」運算符 === 與 !==,用來判斷兩個物件參考是否指向同一個實例,詳見 Classes and Structures。

每個比較運算符都會回傳一個 Bool 值,用來表示該敘述是否成立:

1 == 1   // true
2 != 1   // true
2 > 1    // true
1 < 2    // true
1 >= 1   // true
2 <= 1   // false

比較運算符最常見的用法是放在條件敘述裡,例如 if:

let name = "world"
if name == "world" {
    print("hello, world")
} else {
    print("I'm sorry \(name), but I don't recognize you")
}
// 印出 "hello, world",因為 name 確實等於 "world"

想更深入了解 if 的用法,請參考控制流一章。

三元條件運算符

三元條件運算符由三個部分組成,形式為 question ? answer1 : answer2。它是一個依條件真假挑選結果的快捷寫法:若 question 為真,就評估並回傳 answer1;否則評估並回傳 answer2。它其實是下面這段程式碼的簡化版本:

if question {
    answer1
} else {
    answer2
}

舉個例子:計算一列(row)的高度。如果這列有標題,就比內容多 50 像素;如果沒有標題,就只多 20 像素。

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight 等於 90

同樣的需求用傳統寫法會長這樣:

let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
    rowHeight = rowHeight + 50
} else {
    rowHeight = rowHeight + 20
}
// rowHeight 等於 90

第一個版本一行以內就把 rowHeight 設定為正確的值,用 let 就足夠,不必額外宣告一個可被修改的 var,也比第二個版本更精簡。

三元條件運算符提供了一種有效率的方式來決定要執行哪個運算式。但也正因為它太簡潔,過度使用反而會拖累可讀性。請避免把多個三元條件運算符巢狀堆疊成一個複雜難讀的敘述。

範圍運算符

Swift 內建兩個範圍運算符,可以簡潔地描述一段連續數值。

閉區間運算符

閉區間運算符 a...b 定義一個從 a 到 b、且包含 a 與 b 的範圍。

當你需要逐一走訪某段範圍內的所有值時,範圍運算符非常好用,例如搭配 for-in 迴圈:

for index in 1...5 {
    print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

關於 for-in 迴圈的更多說明,請參考控制流。

半閉區間運算符

半閉區間運算符 a..<b 定義一個從 a 到 b、但不包含 b 的範圍。之所以叫「半閉」,就是因為它含頭不含尾。

當你搭配從 0 開始索引的集合(例如陣列)時,半閉區間特別順手,因為你可以直接寫到集合的長度而不用擔心越界:

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("Person \(i + 1) is called \(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack

注意這個陣列有四個元素,但 0..<count 只數到 3(也就是最後一個元素的索引),這正是半閉區間的特性。更多關於陣列的內容,請參考陣列一章。

邏輯運算符

邏輯運算符用來組合或反轉布林值 true 與 false。Swift 支援三個源自 C 的標準邏輯運算符:

  • 邏輯 NOT !a
  • 邏輯 AND a && b
  • 邏輯 OR a || b

邏輯非運算符

邏輯非運算符 !a 會把布林值反轉:true 變 false,false 變 true。

它是前置運算符,緊貼在它所修飾的值前面,中間不留空白,唸起來就是「不是」:

let allowedEntry = false
if !allowedEntry {
    print("ACCESS DENIED")
}
// 印出 "ACCESS DENIED"

if !allowedEntry 可以理解成「如果 not allowedEntry」,也就是當 allowedEntry 為 false 時才會執行後面的敘述。

這個例子也說明了命名的重要性:精心挑選的布林常數與變數名稱,能讓程式碼保持可讀,同時避開雙重否定所帶來的邏輯混淆。

邏輯與運算符

邏輯 AND 運算符 a && b 要求 a 與 b 同時為 true,整個運算式才成立;只要其中一方為 false,結果就是 false。

值得留意的是,如果第一個運算數已經是 false,第二個運算數根本不會被評估——既然結果注定是 false,就沒有必要再往下判斷。這個特性稱為短路評估(short-circuit evaluation)。

下面這個例子檢查兩個布林值,只有兩者皆為 true 時才印出 Welcome,否則印出 ACCESS DENIED:

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 印出 "ACCESS DENIED"

邏輯或運算符

邏輯 OR 運算符 a || b 只要 a 或 b 有一個為 true,整個運算式就成立。

它同樣採用短路評估:如果左側已經是 true,右側就不會再被計算,因為結果不可能因此改變。

下面的例子中,hasDoorKey 為 false,但 knowsOverridePassword 為 true。由於至少有一個為 true,整體結果成立,印出 Welcome!

let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 印出 "Welcome!"

複合邏輯運算式

你可以把多個邏輯運算符串接起來,組成更長的複合運算式:

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 印出 "Welcome!"

這裡把前面提過的 && 與 || 結合起來,形成一條較長的判斷鏈。看起來有點繞,但本質上仍是兩兩比較:可以粗略看成 A && B || C || D,依運算子的優先順序由左至右求值。只要牢記「&& 要兩邊都為 true,|| 只要一邊為 true」這條規則,任何複合邏輯運算式都能被拆解清楚。

善用括號讓意圖更明確

在複合運算式中加上括號,可以讓邏輯意圖一目了然。以上面的例子來說,把前半段用括號包起來,閱讀者就不必再猜優先順序:

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 印出 "Welcome!"

括號本身不影響結果,但它大幅降低了誤讀的風險。在條件變得複雜時,加上一層括號往往比多寫十行註解更有效。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved