運算符是程式語言裡最基礎、也最高頻的表達工具。它可以是一個符號,也可以是一段關鍵字,用來檢查、修改或組合數值。最直觀的例子是加法運算符 +,把兩個數字相加寫成 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。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 == ba != ba > ba < ba >= ba <= bSwift 另外還提供兩個「恆等」運算符
===與!==,用來判斷兩個物件參考是否指向同一個實例,詳見 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 的標準邏輯運算符:
!aa && ba || 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!"
括號本身不影響結果,但它大幅降低了誤讀的風險。在條件變得複雜時,加上一層括號往往比多寫十行註解更有效。