Swift5.2-基本的操做（中文文檔）

引言

繼續學習Swift文檔，從上一章節：基礎，咱們學習了Swift基礎，如今，咱們學習Swift的基本操做。這一章節的內容比較簡單，一些運算符操做基本上和C、OC上的同樣，不過在Swift上也有它特有的一些運算符，能夠簡化代碼，如**??操做符、...操做符、..<**操做符和單邊值域，不熟悉的朋友能夠單獨去看這部份內容（在七、八、9三個小節），其餘的運算符就能夠跳過了。因爲篇幅較長，這裏分篇來記錄，接下來，開始吧！

若是你已經掌握了Swift的基礎，那麼請參閱下一章節：字符串和字符

基本的操做

運算符是用於檢查、更改或組合值的特殊符號或短語。例如，加法運算符(+)將兩個數字相加，如let i = 1 + 2;邏輯和運算符(&&)組合兩個布爾值，如if enteredDoorCode && passedRetinaScan。

Swift支持大多數標準的C操做符，並改進了一些功能，以消除常見的編碼錯誤。賦值操做符(=)不返回值，以防止在使用equal to操做符(==)時錯誤地使用它。算術運算符(+、-、*、/、%等等)檢測並禁止值溢出，以免在處理大於或小於存儲它們的類型容許的值範圍的數字時出現意外結果。您可使用Swift的溢出操做符(如溢出操做符中所述)來選擇對溢出行爲進行值設置。

Swift還提供了C中沒有的範圍操做符，好比a..< b和a…b做爲表示值範圍的快捷方式。

本章介紹了Swift中經常使用的操做符。高級操做符涵蓋Swift的操做符，並描述如何定義您本身自定義操做符和實現標準操做符爲您本身自定義類型。

1 術語

運算符有一元、二元或三元:

• 一元操做符對單個目標(好比-a)進行操做。一元前綴操做符當即出如今它們的目標(好比!b)以前，一元后綴操做符當即出如今它們的目標(好比c!)以後。
• 二元操做符對兩個目標(例如2 + 3)進行操做，而且是中綴，由於它們出如今兩個目標之間。
• 三元運算符對三個目標進行操做。和C同樣，Swift只有一個三元運算符，三元條件運算符(a ? b : c)。

操做符影響的值是操做數。在表達式1 + 2中，+符號是一個二元運算符，它的兩個操做數是值1和2。

2 賦值運算符

賦值操做符(a = b)初始化或更新a的值爲b:

let b = 10
var a = 5
a = b
// a is now equal to 10
複製代碼

若是賦值的右邊是一個有多個值的元組，那麼它的元素能夠一次分解爲多個常量或變量:

let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2
複製代碼

與C和Objective-C中的賦值操做符不一樣，Swift中的賦值操做符自己不返回值。如下陳述無效:

if x = y {
    // This is not valid, because x = y does not return a value.
}
複製代碼

該特性防止在實際使用equal to操做符(==)時意外使用賦值操做符(=)。經過設置if x = y無效，Swift能夠幫助您避免代碼中出現這類錯誤。

3 算術運算符

針對數值類型，Swift提供了四種基本的算術運算符：

• 加法（+）
• 減法（-）
• 乘法 （*）
• 除法 （/）

1 + 2       // equals 3
5 - 3       // equals 2
2 * 3       // equals 6
10.0 / 2.5  // equals 4.0
複製代碼

與C和Objective-C中的算術運算符不一樣，Swift算術運算符默認不容許值溢出。您能夠選擇使用Swift的溢出操做符(如a &+ b)來計算溢出行爲的值。請參閱溢出操做符。

字符串鏈接也支持加法運算符:

"hello, " + "world"  // equals "hello, world"
複製代碼

3.1 餘數操做符

餘數運算符(a % b)計算出a中能夠容納多少個b的倍數，並返回剩餘的值(稱爲餘數)。

注意 餘數運算符(%)在其餘語言中也稱爲模運算符。可是，它在負數中的表現意味着，嚴格地說，它是一個餘數而不是模運算。

下面是餘數運算符的工做原理。要計算9 % 4，你首先要算出9能裝下多少個4s:

能夠在9中放入兩個4s，餘數爲1(用橙色表示)。

在Swift中能夠這樣寫：

9 % 4    // equals 1
複製代碼

爲了肯定a % b的答案，%運算符計算如下等式並返回餘數做爲輸出:

a = (b x some multiplier) + remainder
複製代碼

some multiplier是a中b的最大倍數。

將9和4插入到這個方程，獲得:

9 = (4 x 2) + 1
複製代碼

計算a的負值的餘數時採用相同的方法:

-9 % 4   // equals -1
複製代碼

將-9和4插入方程，獲得:

-9 = (4 x -2) + -1
複製代碼

餘數爲-1。

當b爲負值時，b的符號被忽略。這意味着a % b和a % -b老是給出相同的答案。

3.2 一元減(-)操做符

數字值的符號能夠經過前綴-來進行切換，也就是一元減運算符:

let three = 3
let minusThree = -three       // minusThree equals -3
let plusThree = -minusThree   // plusThree equals 3, or "minus minus three"
複製代碼

一元減運算符(-)直接放在它所操做的值前面，沒有任何空格。

3.3 一元加(+)操做符

一元加號運算符(+)只返回它所操做的值，沒有任何變化:

let minusSix = -6
let alsoMinusSix = +minusSix  // alsoMinusSix equals -6
複製代碼

雖然一元加號運算符實際上沒有任何做用，可是您能夠在代碼中使用它來爲正數提供對稱，同時也可使用一元減號運算符來爲負數提供對稱。

4 複合賦值操做符

像C同樣，Swift提供了將賦值(=)與另外一個操做組合起來的複合賦值操做符。一個例子是加法賦值操做符(+=):

var a = 1
a += 2
// a is now equal to 3
複製代碼

表達式a += 2是a = a + 2的簡寫。有效地，加法和賦值被合併到一個運算符中，同時執行兩個任務。

注意 複合賦值操做符不返回值。例如，你不能寫b = a += 2。

有關Swift標準庫提供的操做符的信息，請參見操做符聲明。

5 比較運算符

Swift支持全部標準C比較運算符:

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

注意 Swift還提供了兩個身份操做符(===和!==)，用於測試兩個對象引用是否都引用同一個對象實例。有關更多信息，請參見標識操做符。

每一個比較運算符都返回一個Bool值來表示語句是否爲真:

1 == 1   // true because 1 is equal to 1
2 != 1   // true because 2 is not equal to 1
2 > 1    // true because 2 is greater than 1
1 < 2    // true because 1 is less than 2
1 >= 1   // true because 1 is greater than or equal to 1
2 <= 1   // false because 2 is not less than or equal to 1
複製代碼

比較運算符經常使用於條件語句中，如if語句:

let name = "world"
if name == "world" {
    print("hello, world")
} else {
    print("I'm sorry \(name), but I don't recognize you")
}
// Prints "hello, world", because name is indeed equal to "world".
複製代碼

有關If更多內容，請參閱控制流。

若是兩個元組具備相同的類型和相同數量的值，則能夠比較它們。元組從左到右進行比較，一次一個值，直到比較發現兩個不相等的值爲止。比較這兩個值，比較的結果決定元組比較的整體結果。若是全部元素都相等，則元組自己也相等。例如:

(1, "zebra") < (2, "apple")   // true because 1 is less than 2; "zebra" and "apple" are not compared
(3, "apple") < (3, "bird")    // true because 3 is equal to 3, and "apple" is less than "bird"
(4, "dog") == (4, "dog")      // true because 4 is equal to 4, and "dog" is equal to "dog"
複製代碼

在上面的示例中，您能夠在第一行看到從左到右的比較行爲。由於1小於2，因此(1，「zebra」)被認爲小於(2，「apple」)，而與元組中的其餘值無關。「zebra」不小於「apple」並不重要，由於比較已經由元組的第一個元素決定了。可是，當元組的第一個元素相同時，將比較它們的第二個元素—這是在第二和第三行發生的事情。

只有當運算符能夠應用於相應元組中的每一個值時，才能將元組與給定的運算符進行比較。例如，以下面的代碼所示，您能夠比較類型(String, Int)的兩個元組，由於字符串和Int值均可以使用<操做符進行比較。相反，類型的兩個元組(String、Bool)不能與<操做符進行比較，由於<操做符不能應用於Bool值。

("blue", -1) < ("purple", 1)        // OK, evaluates to true
("blue", false) < ("purple", true)  // Error because < can't compare Boolean values 複製代碼

注意 Swift標準庫包含元組比較運算符，用於元素少於七個的元組。要比較具備7個或更多元素的元組，必須本身實現比較運算符。

6 元條件運算符

三元條件運算符是一種特殊的運算符，由三部分組成：question ?answer1 : answer2。這是一個計算兩個表達式中的一個的捷徑，基於問題是真的仍是假的。若是question爲真，它計算answer1並返回它的值;不然，它將計算answer2並返回其值。

三元條件運算符是如下代碼的簡寫:

if question {
    answer1
} else {
    answer2
}
複製代碼

下面是一個示例，它計算錶行的高度。若是行有標題，行高應該比內容高50點，若是行沒有標題，行高20點:

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90
複製代碼

上面代碼是下面代碼的簡寫：

let contentHeight = 40
let hasHeader = true
let rowHeight: Int
if hasHeader {
    rowHeight = contentHeight + 50
} else {
    rowHeight = contentHeight + 20
}
// rowHeight is equal to 90
複製代碼

第一個示例使用了三元條件運算符，這意味着能夠在一行代碼中將rowh8設置爲正確的值，這比第二個示例中使用的代碼更簡潔。

三元條件運算符提供了一種有效的簡寫方式來決定兩個表達式中的哪個要考慮。可是，使用三元條件運算符時要當心。若是過分使用，它的簡潔性會致使難以閱讀的代碼。避免將三元條件運算符的多個實例組合成一個複合語句。

7 Nil-Coalescing操做符（ ??操做符 ）

nil-coalescing操做符(a ?? b)若是一個可選的a包含一個值，則展開它;若是a爲nil，則返回一個默認值b。表達式a始終是可選類型。表達式b必須匹配存儲在a中的類型。

Nil-Coalescing操做符是下面代碼的簡寫：

a != nil ? a! : b
複製代碼

上面的代碼使用三元條件運算符和強制展開(a!)，當a不是nil時訪問包裝在a中的值，不然返回b。nil-coalescing操做符提供了一種更優雅的方式，以簡潔和可讀的形式封裝這種條件檢查和展開。

注意 若是a的值是非nil，那麼b的值就不會被計算。這就是所謂的短路評估。

下面的例子使用了nil-coalescing操做符來選擇默認的顏色名稱和可選的用戶定義的顏色名稱:

let defaultColorName = "red"
var userDefinedColorName: String?   // defaults to nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default of "red"
複製代碼

userDefinedColorName變量被定義爲一個可選字符串，默認值爲nil。由於userDefinedColorName是可選類型，因此可使用nil-coalescing操做符來考慮它的值。在上面的示例中，操做符用於肯定名爲colorNameToUse的字符串變量的初始值。由於userDefinedColorName是nil，表達式userDefinedColorName ??defaultColorName返回defaultColorName的值，或者「red」。

若是你給userDefinedColorName分配一個非nil值，並再次執行nl -coalescing操做符檢查，userDefinedColorName內的值將被使用，而不是默認值:

userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to "green"
複製代碼

8 範圍操做符

Swift包括幾個範圍操做符，它們是表示值範圍的快捷方式。

8.1 封閉範圍運算符 （ ... 操做符 ）

閉值域運算(a…b)定義了從a到b的值域，包括a和b的值。a的值不能大於b。

閉合範圍運算符在迭代一個範圍時很是有用，在這個範圍內你須要使用全部的值，例如forin循環:

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循環，參閱控制流。

8.2 半開範圍操做符（ ..< 操做符）

半開區間運算符(a..<b)定義了從a到b的範圍，但不包括b。之因此稱之爲半開區間，是由於它包含了第一個值，但沒有包含最終值。與封閉範圍操做符同樣，a的值不能大於b。若是a的值等於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
複製代碼

注意，數組包含4個項，可是0..<count只計算到3(數組中最後一項的索引)，由於它是半開放的範圍。有關數組的更多信息，請參見數組。

8.3 單邊值域

對於在一個方向上儘量連續的範圍，封閉範圍操做符有另外一種形式—例如，包含數組從索引2到數組末尾的全部元素的範圍。在這些狀況下，能夠忽略範圍操做符一側的值。這種值域稱爲單邊值域，由於運算符只有一邊有值。例如:

for name in names[2...] {
    print(name)
}
// Brian
// Jack

for name in names[...2] {
    print(name)
}
// Anna
// Alex
// Brian
複製代碼

半開式值域運算符也有一個單邊形式，只有它的最終值。就像在兩邊都包含值同樣，最終值也不屬於範圍內。例如:

for name in names[..<2] {
    print(name)
}
// Anna
// Alex
複製代碼

單邊值域能夠在其餘上下文中使用，而不只僅是下標。您不能遍歷遺漏第一個值的單邊值域，由於不清楚迭代應該從哪裏開始。您能夠迭代一個單邊的值域，省略其最終值;可是，因爲範圍是無限延續的，因此請確保爲循環添加了一個顯式的結束條件。還能夠檢查單邊值域是否包含特定值，以下面的代碼所示。

let range = ...5
range.contains(7)   // false
range.contains(4)   // true
range.contains(-1)  // true
複製代碼

9 邏輯運算符

邏輯運算符修改或組合布爾邏輯值true和false。Swift支持基於c語言的三種標準邏輯運算符:

• 邏輯 非 (!a)
• 邏輯 與 (a && b)
• 邏輯 或 (a || b)

9.1 邏輯非運算符

邏輯非操做符(!a)反轉布爾值，使真變爲假，假變爲真。

邏輯非操做符是一個前綴操做符，它出如今它所操做的值的前面，沒有任何空格。能夠理解爲「非 a」，以下例所示:

let allowedEntry = false
if !allowedEntry {
    print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"
複製代碼

「if !allowedEntry」能夠理解爲「if not allowed entry」。後面的行只在「not allowed entry」爲真時執行;也就是說，若是allowedEntry爲false。

與本例同樣，謹慎選擇布爾常量和變量名有助於保持代碼可讀性和簡潔，同時避免雙重否認或邏輯語句混亂。

9.2 邏輯與運算符

邏輯和運算符(a && b)建立邏輯表達式，其中兩個值必須爲真，整個表達式也爲真。

若是任一值爲假，則整個表達式也爲假。事實上，若是第一個值爲假，第二個值甚至不會計算，由於它不可能使整個表達式等於真。這就是所謂的短路評估。

這個例子考慮了兩個Bool值，只有當兩個值都爲真時才容許訪問:

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"
複製代碼

9.3 邏輯或運算符

邏輯或操做符(|| b)是由兩個相鄰管道字符組成的中綴操做符。您可使用它來建立邏輯表達式，其中兩個值中只有一個必須爲真才能使整個表達式爲真。

與上面的邏輯和運算符同樣，邏輯或運算符使用短路求值來考慮其表達式。若是邏輯或表達式的左邊爲真，則不計算右邊的值，由於它不能改變整個表達式的結果。

在下例中，第一個Bool值(hasDoorKey)爲假，但第二個值(knowsOverridePassword)爲真。由於一個值爲真，整個表達式的計算結果也爲真，所以容許訪問:

let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"
複製代碼

9.4 組合的邏輯運算符

您能夠組合多個邏輯運算符來建立更長的複合表達式:

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"
複製代碼

這個示例使用多個&&和||操做符建立一個更長的複合表達式。可是，&&和||操做符仍然只對兩個值進行操做，所以這其實是三個鏈接在一塊兒的較小的表達式。這個例子能夠理解爲:

若是咱們輸入了正確的門碼而且經過了視網膜掃描，或者若是咱們有一個有效的門鑰匙，或者若是咱們知道緊急控制密碼，那麼就容許進入。

根據enteredDoorCode、passedRetinaScan和hasDoorKey的值，前兩個子表達式爲false。可是，緊急覆蓋密碼是已知的，所以整個複合表達式的計算結果仍然爲true。

注意 Swift邏輯運算符&&和||是左關聯的，這意味着包含多個邏輯運算符的複合表達式首先計算最左邊的子表達式。

9.5 用括號分隔多個邏輯運算符

有時，若是不是嚴格須要括號，那麼包含括號是頗有用的，這樣可使複雜表達式的意圖更容易理解。在上面的door access示例中，在複合表達式的第一部分周圍添加括號以明確其意圖是頗有用的:

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"
複製代碼

括號清楚地代表前兩個值被視爲整個邏輯中單獨可能的狀態的一部分。複合表達式的輸出沒有變化，但整體意圖對讀者更清晰。可讀性老是比簡潔更重要;使用括號來幫助明確你的意圖。

總結

這一章節的內容比較簡單，一些運算符操做基本上和C、OC上的同樣，不過在Swift上也有它特有的一些運算符，能夠簡化代碼，以下所示：

• ?? 操做符
• 封閉範圍操做符（...） 、半開範圍操做符（..<） 和單邊值域

具體的做用，能夠翻看上面的內容找到答案。

最後，喜歡的朋友能夠打個star哦！這樣我才更有動力繼續下去，嘎嘎嘎~

上一章節：基礎

下一章節：字符串和字符

參考文檔：Swift - Basic Operators