運算符(Operator)是用來檢查，改變或合并值的一種特殊符號或短語。例如，加號運算符讓兩個數字相加(如：let i = 1 + 2)，還有些更復雜的運算符，如邏輯與運算符(&&)(如：if enteredDoorCode && passedRetinaScan)和自增運算符(++i)（將 i 的值加 1 的便捷寫法）。

Swift 支持標準C語言的大多數運算符，并且改進了一些特性以規避常見的代碼錯誤。賦值運算符(=)是沒有返回值的，這樣是為了避免在使用等于運算符(==)時誤用了賦值運算符(=)。算術運算符（+，-，*，/，% 等等）會偵測并阻止值溢出，可避免在運算時超出存儲類型的值域范圍（比實際運算結果大或小，或不精準--Joe.Huang）。如果需要支持溢出行為，可以選用 Swift 的溢出運算符，詳情可見 溢出運算符（后面章節譯到）。

與C語言不同的是，Swift 允許對浮點數求余(%)。Swift 還提供了C語言所沒有的兩個區間運算符（a..b和a...b），作為表示值域范圍的便捷寫法。

本章介紹 Swift 中的常用運算符。高級運算符 （后面章節譯到） 一章涵蓋了 Swift 中的高級運算符，并講解了如何自定義運算符，以及讓標準運算符支持自定義類型的運算。

運算符術語

運算符分為一元，二元，三元運算符：

· 一元運算符（unary operator）對單個目標進行運算（如 -a）。一元運算符前綴（unary PRefix operator）緊跟運算目標之前（如 !b），而一元運算符后綴（unary postfix operator）則緊跟運算目標之后（如 i++）。

· 二元運算符（binary operator）對兩個目標進行運算（如 2 + 3），它們屬于中綴（infix）運算符，因為（運算符號）出現在兩個運算目標之間。

· 三元運算符（ternary operator）對三個目標進行運算。與 C 語言一樣，Swift 只有一個三元運算符：三元條件運算符（即 a ? b : c）。

運算符操作的值稱為運算元（operands）。在表達式 1 + 2 中，+ 符號是二元運算符，它的兩個運算元為值 1與值 2。

賦值運算符

賦值運算符（assignment operator，a = b）用 b 的值初始化或更新 a 的值：

1 let b = 102 var a = 53 a = b4 // a is now equal to 105 //a現在等于10

如果賦值語句的右側是一個包含多個值的元組，元組的元素可一次性用多個常量或變量分解提取出來（上一章講解元組時提到過分解元組值的方法--Joe.Huang）：

1 let (x, y) = (1, 2)2 // x is equal to 1, and y is equal to 23 //x等于1，y等于2

與 C 或 Objective-C 語言的賦值運算符不同，Swift 語言的賦值運算符本身沒有返回值。因此下面的語句不正確：

1 if x = y {2     // this is not valid, because x = y does not return a value3     // 這是無效的，因為 x = y 不會返回一個值 （x==y才可以，--Joe.Huang）4 }

該特性可避免在使用等于運算符(==)時誤用了賦值運算符(=)。通過否認 if x = y 的有效性，Swift 將幫助你規避代碼中出現這樣的錯誤。

算術運算符

Swift支持對所有數字類型使用四種標準算術運算符：

· 加：+

· 減：-

· 乘：*

· 除：/

1 1 + 2       //  等于32 5 - 3       //  等于23 2 * 3       //  等于64 10.0 / 2.5  //  等于4.0

與 C / Objective-C 語言的算術運算符不同，Swift 的算術運算符默認不允許值溢出。如果需要支持溢出行為，可以選用 Swift 的溢出運算符(如，a &+ b)，詳情可見 溢出運算符（后面章節譯到）。

加號運算符也支持 String 拼接：

"hello, " + "world"  // 等于 "hello, world"

可以將兩個 Character （字符，Unicode字符--Joe.Huang）值相加，或將一個 Character 值與一個 String 值相加，得到新的 String 值：

1 let dog: Character = ""2 let cow: Character = ""3 let dogCow = dog + cow4 // dogCow 等于 ""

 詳見 字符與字符串拼接 (后面章節譯到)：

求余運算符

求余運算符（remainder operator，a % b）求出 a 包含多少個 b，并返回剩余的值（即整除后的余數 remainder）。

 注：

求余運算符（%）在其他語言中也稱作求模運算符（modulo operator）。但對負數的運算結果表明：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

a 為負數時，求余方法不變：

-9 % 4   // 等于 -1

把 -9 和 4 代入等式：

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

得到的余數值為-1。

b 為負值（-b）時，b 的負號將被忽略。因此 a % b 與 a % -b 總是返回相同的結果。

浮點數的求余計算

與 C / Objective-C 語言的余數運算符不同，Swift 的余數運算符還能對浮點數進行求余計算：

8 % 2.5   // equals 0.5

上例中，8 除以 2.5 等于 3，余數為 0.5，因此余數運算符返回 Double 型的值 0.5。

自增與自減運算符

與 C 語言類似，Swift 也提供了自增運算符（++）與自減運算符（--），作為將數字變量的值加上或減去 1 的便捷寫法。任何整型或浮點型的變量都可以使用這兩個運算符。

1 var i = 02 ++i      // i 現在等于 1

每次調用 ++i 時，i 的值就會增加 1。本質上，++i 就是 i = i + 1 的便捷寫法。類似地，--i 也相當于 i = i - 1。

++ 與 -- 兩對符號可以作為前綴或后綴運算符使用。++i 與 i++ 均可用來將 i 的值加 1。類似地，--i 與 i-- 均可用來將 i 的值減去 1。

注意，這些運算符不僅會改變 i 的值，還會返回一個值。如果你只需要將自增或自減后的值存放在 i 中，那你可以忽略運算符的返回值。但如果你確實要用到返回值，要注意前綴及后綴運算符返回值的差異，規則如下：

· 如果運算符在變量名前面，先改變它的值，再返回其值。

· 如果運算符在變量名后面，先返回原值，再改變它的值。

如例：

1 var a = 02 let b = ++a3 // a 和 b 現在都等于 1，即改變a的值，再返回4 let c = a++5 // a 現在等于 2, 但 c 還是自增前的值 1，即先返回的a的原值，再改變其值

在上例中，let b = ++a 先增加 a 的值（加1），然后才返回它的值。因此 a 與 b 都等于新的值 1。

但是，let c = a++ 先返回 a 的原值（加1之前的值），然后才增加 a 的值。即 c 得到了原值 1，然后 a 被更新為新值 2。

除非你需要利用 i++ 的這一特性，建議你在所有情況下都使用 ++i 與 --i，因為它們先修改 i 再返回修改后的值的動作更符合邏輯。

一元減號運算符

數值前加上前綴 - ，這個前綴運算符 - 就稱為一元減號運算符：

1 let three = 32 let minusThree = -three       // minusThree 等于 -33 let plusThree = -minusThree   // plusThree 等于 3, 或等于 "減去 minusThree"

一元減號運算符（-）緊靠所要操作的值之前，無需任何空格。

一元加號運算符

一元加號運算符（+）直接返回所操作的值，不作任何處理：

1 let minusSix = -62 let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6

盡管一元加號運算符實際上不作任何運算，代碼中仍然可以用它（提供語義信息，一元減號運算符表示負數，一元加號運算符表示正數--Joe.Huang）與表示負數的一元減號運算符形成對比。

復合賦值運算符

與 C 語言類似，Swift 也提供復合賦值運算符（compound assignment operator）將賦值運算符（=）與其他運算組合起來使用。例如加法賦值運算符（addition assignment operator，+=）：

1 var a = 12 a += 23 // a 等于 3

上例中的表達式 a = a + 2 簡寫為 a += 2，加法和賦值兩項操作組合為一個單項操作，執行時非常高效。

注：

復合賦值操作沒有返回值，即，你不能寫：let b = a += 2，這一操作與前面所提到的自增自減操作是不同的。

復合賦值運算符的完整列表可在 表達式 一章中找到（后面章節譯到）。

比較運算符

Swift支持標準C 的比較運算符：

      等于   (a == b)
   不等于   (a != b)
      大于   (a > b)
      小于   (a < b)
 大于等于  (a >= b)
 小于等于  (a <= b)

注：

Swift還提供了恒等（===）和不恒等（!==）兩個鑒別運算符，你可以用它測試兩個對象是否引用了同一個對象實例。更多詳情請參考 類和結構 一章（后面章節譯到）。

每個比較運算符都會返回一個 Bool 值，檢測表達式是否成立：

1 1 == 1   // true, 因為 1 等于 12 2 != 1   // true, 因為 2 不等于 13 2 > 1    // true, 因為 2 大于 14 1 < 2    // true, 因為 1 小于 25 1 >= 1   // true, 因為 1 大于等于 16 2 <= 1   // false, 因為 2 大于等于 1

比較運算符常見于條件表達式中，如 if 條件句：

1 let name = "world"2 if name == "world" {3     println("hello, world")4 } else {5     println("I'm sorry /(name), but I don't recognize you")6     //輸出（”對不起/name，我不認識你“）7 }8 // prints "hello, world", because name is indeed equal to "world"9 //輸出 "hello world",因為 name 確實等于"world"

if 語句的更多介紹，詳見 流程控制 一章（后面章節譯到）。

三元條件運算符

三元運算符是一種特殊運算符，由三個部分組成，表現形式為：question ? answer1 : answer2。它是一種求值簡寫：根據 question 是否成立，從兩個表達式中取出一個并求值。

如果 question 成立，則計算 answer1 的結果并返回其值；否則計算 answer2 并返回其值。

三元條件運算符是如下代碼的縮寫：

1 if question {2     answer13 } else {4     answer25 }

下面的例子將計算表格某行的像素高度。如果該行有表頭，則行高應比內容高度高 50 個像素；如果沒有表頭，則只高出 20 個像素：

1 let contentHeight = 402 let hasHeader = true3 let rowHeight = contentHeight + (hasHeader ? 50 : 20)4 // rowHeight(行高) 等于 90

上例便是如下代碼的縮寫：

1 let contentHeight = 402 let hasHeader = true3 var rowHeight = contentHeight4 if hasHeader {5     rowHeight = rowHeight + 506 } else {7     rowHeight = rowHeight + 208 }9 // rowHeight(行高) 等于 90

使用三元條件運算符的例子說明，可以僅用一行代碼就將行高設為正確的值。這比（不用三元運算符的）第二個例子簡潔得多，并且行高(rowHeight)無需定義為變量，因為不再需要用 if 語句修改其值。

三元條件運算符提供了二選一的高效寫法。但使用三元條件運算符應小心。如果過度使用，其簡明性可能導致代碼可讀性差。應避免將多個三元條件運算符組合在同一個語句中。

區間運算符

Swift有兩個區間運算法，是表示值域的簡便寫法。

閉區間運算符

區間運算符（a...b）定義了 a 到 b 的區間范圍，包括 a 和 b 在內。

閉區間運算符在需要遍歷某區間內所有的值時很有用，如在 for-in 循環中使用：

1 for index in 1...5 {2     println("/(index) times 5 is /(index * 5)")3     //輸出（"/(index)乘以 5 得 (/index * 5)"）4 }5 // 1 乘以 5 得 56 // 2 乘以 5 得 107 // 3 乘以 5 得 158 // 4 乘以 5 得 209 // 5 乘以 5 得 25

for-in 語句的更多介紹，詳見 流程控制 一章（后面章節譯到）。

半閉區間運算符

半閉區間運算符（a..b）定義了從 a 到 b 的區間，但 b 不包括在內。說它是半閉區間，是因為第一個值包含在區間內，但最后一個值在區間外。

半閉區間在處理從 0 開始計數的列表時有用，如遍歷數組，可從 0 數到列表的長度（但不包括長度值本身）：

1 let names = ["Anna", "Alex", "Brian", "Jack"]2 let count = names.count3 for i in 0..count {4     println("Person /(i + 1) is called /(names[i])")5 }6 // Person 1 名字是 Anna7 // Person 2 名字是 Alex8 // Person 3 名字是 Brian9 // Person 4 名字是 Jack

注意，數組包含四個元素，但因為是半閉區間，所以 0..count 只數到 3（數組中最后一個元素的索引號）。數組更多信息詳見 數組 一章（后面章節譯到）。

邏輯運算符

邏輯運算符是對布爾邏輯值 true 或 false 的組合操作，Swift 支持 C 及其衍生語言的三種標準邏輯運算符：

· 邏輯非（!a）

· 邏輯與（a && b）

· 邏輯或（a || b）

邏輯非運算符

邏輯非運算符對布爾值取反，即 true 變成 false，false 變成true。

邏輯非運算符是一個前綴運算符，緊跟在所操作值的前面，沒有任何空格符?？梢岳斫鉃?非"，如下例：

1 let allowedEntry = false2 if !allowedEntry {3     println("access DENIED")4 }5 // prints "ACCESS DENIED"6 //輸出”ACCESS DENIED“

代碼中的 if !allowedEntry 可以理解為“如果不允許進入”。隨后的下一行代碼僅當“不允許進入”成立時才會執行；即 allowedEntry 為 false 時才執行。

如上例，布爾值常量及變量的名稱應謹慎選擇命名，方可確保代碼簡明又具可讀性，同時也應避免使用雙重否定或引起混淆的邏輯語句。

邏輯與運算符

（a && b）構造這樣的邏輯表達式：運算符兩側的值均為 true，整個表達式的求值結果才為 true。

如果有一個值為 false，整個表達式便為 false。事實上，如果第一個值為 false，第二個值將不執行求值運算，因為無論它為何值，整個表達式的值都不可能等于 true。這也被稱為短路求值（short-circuit evaluation）。

下面的例子驗證兩個值，當兩個值都為 true 時才能訪問：

1 let enteredDoorCode = true2 let passedRetinaScan = false3 if enteredDoorCode && passedRetinaScan {4     println("Welcome!")5 } else {6     println("ACCESS DENIED")7 }8 // prints "ACCESS DENIED"  輸出"ACCESS DENIED"

邏輯或運算符

（a || b）屬于中綴運算符，由兩個連續的豎線構成。它用來構造這樣的表達式：當兩個值中有一個為 true時，整個表達式為 true 。

與前面的邏輯與運算符一樣，邏輯或運算符在檢測它的兩個表達式時，也使用“短路求值”法。只要邏輯或表達式左側為 true，其右側將不執行求值運算，因為這時右側的值對整個表達式的結果不再有影響。

下例中，第一個 Bool 值（hasDoorKey）為 false，但第二個值（knowOverridePassWord）為 true。因為有一個值為 true，所以整個表達式的求值結果也為 true，因此允許訪問：

1 let hasDoorKey = false2 let knowsOverridePassword = true3 if hasDoorKey || knowsOverridePassword {4     println("Welcome!")5 } else {6     println("ACCESS DENIED")7 }8 // prints "Welcome!"  輸出"Welcome!"

組合使用邏輯運算符

可以將多個邏輯運算符組合起來構成一個較長的復合表達式。

1 “if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {2     println("Welcome!")3 } else {4     println("ACCESS DENIED")5 }6 // prints "Welcome!"  輸出"Welcome!"

本例使用多個 && 及 || 運算符構成一條較長的復合表達式。不過，&& 與 || 運算符操作的仍然是兩個值，因此該組合表達式實際上是由三個較短的表達式連立而成。它可以這樣理解：

如果我們輸入了正確的門禁密碼、并且通過了視網膜掃描；或者如果我們有門鑰匙；或者如果我們知道緊急的備用密碼，則允許訪問。

根據 enteredDoorCode、passedRetinaScan、hasDoorKey 三個常量推算，前兩個小表達式的值均為 false。不過我們知道緊急的備用密碼（knowsOverridePassword 為 true），因此整個復合表達式的求值結果仍然為 true。

顯式括號

有時（從語法來看）括號并不是必需的，但加上括號卻很有用，它可以讓復雜表達式的易于閱讀。 在上例中，為組合表達式的第一部分加上括號，可使其意圖更明顯：

1 if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {2     println("Welcome!")3 } else {4     println("ACCESS DENIED")5 }6 // prints "Welcome!"  //輸出"Welcome!"

括號將前兩個值與其他值分隔開來，使其作為整體邏輯中的一種可選狀態的意思更加明顯。組合表達式的結果不會改變，但對讀者而言，整體意圖更加清晰?？勺x性總是優先于簡潔性；應盡可能在合適的地方使用括號，使你的邏輯更加明晰。

謝謝，Swifter-QQ群：362232993，同好者進~ 

Fork：https://github.com/Joejo/Swift-lesson-for-chinese