Swift5.x-閉包（中文文檔）

時間 2020-07-09

原文原文鏈接

引言

繼續學習Swift文檔，從上一章節：函數，咱們學習了Swift函數相關的內容，如函數的定義和使用、函數參數、返回值、嵌套函數等這些內容。在定義和用法上，與OC仍是有差別的。如今，咱們學習Swift的閉包相關的內容。因爲篇幅較長，這裏分篇來記錄，接下來，Fighting！html

若是你已經掌握了閉包的使用，那麼請參閱下一章節：枚舉git

閉包

閉包是獨立的功能塊，能夠在代碼中傳遞和使用。 Swift中的閉包相似於C和Objective-C中的塊以及其餘編程語言中的lambda。正則表達式

閉包能夠從定義它們的上下文中捕獲和存儲對任何常量和變量的引用。這稱爲包裝這些常量和變量。 Swift爲您處理捕獲的全部常量或變量進行內存管理。編程

注意
若是您不熟悉捕獲的概念，請不要擔憂。下面在Capturing Values中對此進行了詳細說明。swift

正如函數中介紹的那樣，全局和嵌套函數其實是閉包的特殊狀況。閉包採用如下三種形式之一：api

全局函數是具備名稱且不捕獲任何值的閉包。
嵌套函數是具備名稱的閉包，能夠從其閉包函數捕獲值。
閉包表達式是用輕量級語法編寫的未命名的閉包，能夠從其周圍的上下文中捕獲值。

Swift的閉包表達式具備簡潔明瞭的風格，並經過優化來鼓勵在常見狀況下使用簡潔，簡潔的語法。這些優化包括：數組

從上下文推斷參數和返回值類型
單表達式閉包的隱式返回
速記參數名稱
尾隨閉包語法

1 閉包表達式

嵌套函數中介紹的Nested Functions是命名和定義獨立的代碼塊做爲較大函數的一部分的便捷方法。可是，有時在沒有完整的聲明和名稱的狀況下編寫相似函數的結構的較短版本頗有用。當您使用以函數做爲其一個或多個參數的函數或方法時，尤爲如此。bash

閉包表達式是一種以簡短，集中的語法編寫內聯閉包的方法。閉包表達式提供了幾種語法優化，以簡化形式編寫閉包，而不會形成清晰度或意圖的損失。下面的閉包表達式示例經過在多個迭代中完善sorted（by :)方法的單個示例來講明這些優化，每一個迭代以更簡潔的方式表示相同的功能。網絡

1.1 Sorted方法

Swift的標準庫提供了一種稱爲sorted（by :)的方法，該方法根據您提供的排序閉包的輸出對已知類型的值數組進行排序。完成排序過程後，sorted（by :)方法將返回一個與舊數組具備相同類型和大小的新數組，其元素的排序順序正確。原始數組未經過sorted（by :)方法修改。閉包

下面的閉包表達式示例使用sorted（by :)方法以反向字母順序對String值數組進行排序。這是要排序的初始數組：

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
複製代碼

sorted（by :)方法接受一個閉包，該閉包採用兩個與數組內容相同類型的參數，並返回一個Bool值以說明對這些值進行排序後，第一個值應出如今第二個值以前仍是以後。若是第一個值應出如今第二個值以前，則排序閉包須要返回true，不然返回false。

此示例正在對String值的數組進行排序，所以排序閉包必須是類型爲（String，String）-> Bool的函數。

提供排序閉包的一種方法是編寫正確類型的普通函數，並將其做爲參數傳遞給sorted（by :)方法：

func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
// reversedNames is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
複製代碼

若是第一個字符串（s1）大於第二個字符串（s2），則backward函數（： :)將返回true，指示s1應該出如今排序數組中的s2以前。對於字符串中的字符，「大於」表示「在字母表中出現的時間晚於」。這意味着字母「 B」「大於」字母「 A」，字符串「 Tom」大於字符串「 Tim」。這給出了相反的字母順序，其中「 Barry」位於「 Alex」以前，依此類推。

可是，這其實是編寫單表達式函數（a> b）的漫長過程。在此示例中，最好使用閉包表達式語法內聯地編寫排序閉包。

1.2 閉包表達式語法

閉包表達式語法基本格式：

{ (parameters) -> return type in
    statements
}
複製代碼

閉包表達式語法中的參數能夠是in-out參數，但不能具備默認值。若是您命名可變參數，則可使用可變參數。元組也可用做參數類型和返回類型。

下面的示例從上方顯示了backward（_ : _ :)函數的閉包表達式版本：

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})
複製代碼

請注意，此內聯閉包的參數聲明和返回類型與backward（_ : _ :)函數的聲明相同。在兩種狀況下，它都寫爲（s1：String，s2：String）-> Bool。可是，對於內聯閉包表達式，參數和返回類型寫在花括號內，而不是花括號外。

閉包body的開頭由in關鍵字修飾。此關鍵字表示閉包的參數和返回類型的定義已經完成，而且閉包的body即將開始。

由於閉包的body很是短，因此它甚至能夠寫在一行上：

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )
複製代碼

這說明對sorted（by :)方法的整體調用保持不變。一對括號仍然包裹了該方法的整個參數。可是，該參數如今是內聯閉包。

1.3 從上下文推斷類型

由於排序閉包是做爲方法的參數傳遞的，因此Swift能夠推斷其參數的類型以及它返回的值的類型。 sorted（by :)方法是在字符串數組上調用的，所以其參數必須是（String，String）-> Bool類型的函數。這意味着（String，String）和Bool類型不須要寫爲閉包表達式定義的一部分。因爲能夠推斷全部類型，所以還能夠省略返回箭頭（->）和參數名稱周圍的括號：

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
複製代碼

當將閉包做爲內聯閉包表達式傳遞給函數或方法時，老是能夠推斷出參數類型和返回類型。所以，當閉包用做函數或方法參數時，您無需編寫其完整形式的內聯閉包。

儘管如此，您仍然能夠根據須要使類型顯式，而且若是這樣作能夠避免代碼閱讀者產生歧義，則鼓勵這樣作。在使用sorted（by :)方法的狀況下，閉包的目的很明顯，即發生了排序，而且讀者能夠放心地認爲閉包極可能與String值一塊兒使用，由於它有助於對字符串數組進行排序。

1.4 單表達式閉包的隱式返回

單表達式閉包能夠經過從聲明中省略return關鍵字來隱式返回其單表達式的結果，如上一個示例的此版本所示：

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
複製代碼

在這裏，sorted（by :)方法的參數的函數類型清楚地代表，閉包必須返回Bool值。因爲閉包的主體包含一個返回Bool值的表達式（s1> s2），所以沒有歧義，能夠省略return關鍵字。

1.5 速記參數名稱

Swift會自動爲內聯閉包提供速記參數名稱，可以使用$0，$1，$2等名稱來引用閉包參數的值。

若是您在閉包表達式中使用這些速記參數名稱，則能夠從其定義中省略閉包的參數列表，而速記參數名稱的數量和類型將從預期的函數類型中推斷出來。也能夠省略in關鍵字，由於閉包表達式徹底由其主體組成：

reversedNames = names.sorted(by: { $0 > $1 } )
複製代碼

在這裏，$0和$1指的是閉包的第一個和第二個String參數。

1.6 操做符方法

實際上，還有一種更短的方法來編寫上述閉包表達式。 Swift的String類型將大於運算符（>）的特定於字符串的實現定義爲一種方法，該方法具備兩個String類型的參數，並返回Bool類型的值。這與sorted（by :)方法所需的方法類型徹底匹配。所以，您只需傳遞大於號運算符，Swift就會推斷出您想使用其特定於字符串的實現：

reversedNames = names.sorted(by: >)
複製代碼

有關更多的操做符方法，參見Operator Methods。

2 尾隨閉包

若是您須要將閉包表達式做爲函數的最終參數傳遞給函數，而且閉包表達式很長，那麼將其寫爲尾隨閉包可能會頗有用。即便尾隨閉合符仍然是函數的參數，您也能夠在函數調用的括號後面寫一個尾隨閉合符。使用尾隨閉包語法時，不要在函數調用的過程當中爲第一個閉包編寫參數標籤。一個函數調用能夠包括多個尾隨的閉包。可是，下面的前幾個示例使用單個尾隨閉包。

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}

// Here's how you call this function without using a trailing closure: someFunctionThatTakesAClosure(closure: { // closure's body goes here
})

// Here's how you call this function with a trailing closure instead: someFunctionThatTakesAClosure() { // trailing closure's body goes here
}
複製代碼

上面「閉包表達式語法」部分中的字符串排序閉包能夠寫在sorted（by :)方法的括號以外，做爲尾隨閉包：

reversedNames = names.sorted() { $0 > $1 }
複製代碼

若是將閉包表達式做爲函數或方法的惟一參數提供，而您將該表達式做爲尾隨閉包提供，則在調用函數時，無需在函數或方法的名稱後寫一對括號（）：

reversedNames = names.sorted { $0 > $1 }
複製代碼

當閉包足夠長以至沒法在一行中內聯寫入時，尾隨閉包最有用。例如，Swift的Array類型具備map（_ :)方法，該方法將閉包表達式做爲其單個參數。對數組中的每一個項目調用一次閉包，併爲該項目返回一個替代的映射值（多是其餘類型的）。經過在傳遞給map（_ :)的閉包中編寫代碼，能夠指定映射的性質和返回值的類型。

在將提供的閉包應用於每一個數組元素以後，map（_ :)方法返回一個包含全部新映射值的新數組，其順序與原始數組中相應值的順序相同。

您能夠經過如下方式將map（_ :)方法與結尾的閉包一塊兒使用，以將Int值數組轉換爲String值數組。數組[1六、5八、510]用於建立新數組[「 OneSix」，「 FiveEight」，「 FiveOneZero」]：

let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]
複製代碼

上面的代碼建立了一個整數數字和其名稱的英語版本之間的映射字典。它還定義了一個整數數組，能夠將其轉換爲字符串。

如今，您能夠經過將閉包表達式做爲尾隨閉包傳遞到數組的map（_ :)方法中，來使用數字數組建立String值數組：

let strings = numbers.map { (number) -> String in
    var number = number
    var output = ""
    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0
    return output
}
// strings is inferred to be of type [String]
// its value is ["OneSix", "FiveEight", "FiveOneZero"]
複製代碼

map（_ :)方法爲數組中的每一個項目調用一次閉包表達式。您無需指定閉包的輸入參數number的類型，由於能夠從要映射的數組中的值推斷出該類型。

在此示例中，變量數字用閉包的number參數的值初始化，以即可以在閉包主體中修改該值。（函數和閉包的參數始終是常量。）閉包表達式還指定String的返回類型，以指示將存儲在映射的輸出數組中的類型。

閉包表達式每次被調用時都會構建一個名爲output的字符串。它使用餘數運算符（number％10）計算數字的最後一位，並使用此數字在digitNames詞典中查找適當的字符串。閉包可用於建立任何大於零的整數的字符串表示形式。

注意
調用digitNames字典的下標後會帶有感嘆號（！），由於字典下標會返回一個可選值，以指示若是鍵不存在，則字典查找可能會失敗。在上面的示例中，能夠確保number％10始終是digitNames詞典的有效下標鍵，所以使用感嘆號能夠強制解開存儲在下標的可選返回值中的String值。

從digitNames詞典中檢索到的字符串將添加到output的前面，從而有效地反向構建了數字的字符串版本。（表達式數字％10爲16表示6的值，對於58表示8的值，對於510表示0。）

而後將數字變量除以10。因爲它是整數，所以在除法過程當中會四捨五入，所以16變爲1，58變爲5，而510變爲51。

重複該過程，直到number等於0，這時閉包返回output字符串，並經過map（_ :)方法將其添加到輸出數組中。

在上面的示例中，尾隨閉包語法的使用在閉包支持的函數以後當即將閉包的功能巧妙地封裝起來，而無需將整個閉包包裝在map（_ :)方法的外部括號內。

若是一個函數使用多個閉包，則能夠省略第一個尾隨閉包的參數標籤，並標記其他的尾隨閉包。例如，下面的函數爲照片庫加載圖片：

func loadPicture(from server: Server, completion: (Picture) -> Void, onFailure: () -> Void) {
    if let picture = download("photo.jpg", from: server) {
        completion(picture)
    } else {
        onFailure()
    }
}
複製代碼

調用此函數加載圖片時，將提供兩個閉包。第一個關閉是完成處理程序，該處理程序在成功下載後顯示圖片。第二個閉包是一個錯誤處理程序，向用戶顯示錯誤。

loadPicture(from: someServer) { picture in
    someView.currentPicture = picture
} onFailure: {
    print("Couldn't download the next picture.")
}
複製代碼

在此示例中，loadPicture（from：completion：onFailure :)函數將其網絡任務分派到後臺，並在網絡任務完成時調用兩個完成處理程序之一。經過這種方式編寫函數，可讓您輕鬆地將負責處理網絡故障的代碼與成功下載後更新用戶界面的代碼區分開來，而沒必要使用只處理兩種狀況的閉包。

3 捕獲值

閉包能夠從定義它的周圍環境中捕獲常量和變量。而後，閉包能夠從其主體內部引用和修改那些常量和變量的值，即便定義常量和變量的原始範圍再也不存在。

在Swift中，最簡單的能夠捕獲值的閉包形式是嵌套函數，它寫在另外一個函數的主體內。嵌套函數能夠捕獲其外部函數的任何參數，也能夠捕獲在外部函數中定義的任何常量和變量。

這是一個名爲makeIncrementer的函數的示例，其中包含一個嵌套的函數，稱爲遞增器。嵌套的crementer（）函數從其周圍的上下文中捕獲兩個值，runningTotal和amount。捕獲這些值後，makeIncrementer將遞增器做爲閉合函數返回，該閉合器將在每次調用時將runningTotal增長一個量。

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}
複製代碼

makeIncrementer的返回類型爲（）-> Int。這意味着它將返回一個函數，而不是一個簡單的值。它返回的函數沒有參數，而且每次調用都返回一個Int值。要了解函數如何返回其餘函數，請參見Function Types as Return Types。

makeIncrementer（forIncrement :)函數定義了一個名爲runningTotal的整數變量，用於存儲將要返回的增量器的當前運行總計。該變量的初始值爲0。

makeIncrementer（forIncrement :)函數具備單個Int參數，其參數標籤爲forIncrement，參數名稱爲amount。傳遞給此參數的參數值指定每次調用返回的增量器函數時，應該將runningTotal增長多少。 makeIncrementer函數定義了一個稱爲增量器的嵌套函數，該函數執行實際的增量。此函數只是將金額添加到runningTotal，而後返回結果。

當單獨考慮時，嵌套的增量器（）函數可能看起來很不尋常：

func incrementer() -> Int {
    runningTotal += amount
    return runningTotal
}
複製代碼

incrementer()函數沒有任何參數，但它是從函數體內引用runningTotal和amount的。它經過捕獲周圍函數對runningTotal和amount的引用並在其本身的函數體內使用它們來實現此目的。經過引用捕獲能夠確保在對makeIncrementer的調用結束時runningTotal和數量不會消失，而且還能夠確保下次調用incrementer函數時runningTotal可用。

注意
做爲一種優化，Swift可能會捕獲並存儲值的副本，若是該值未被閉包更改，而且在建立閉包後也未更改該值。

當再也不須要變量處理時，Swift還能夠處理全部與變量處理有關的內存管理。

下例是makeIncrementer的實現：

let incrementByTen = makeIncrementer(forIncrement: 10)
複製代碼

本示例設置一個稱爲crementByTen的常量，以引用一個增量器函數，該函數在每次調用它的runningTotal變量時將其加10。屢次調用該函數可顯示此行爲：

incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30
複製代碼

若是建立第二個incrementer，它將有其本身的存儲的對新的單獨的runningTotal變量的引用：

let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7
複製代碼

再次調用原始的增量器（incrementByTen）會繼續增長其本身的runningTotal變量，而且不會影響incrementBySeven捕獲的變量：

incrementByTen()
// returns a value of 40
複製代碼

注意
若是將閉包分配給類實例的屬性，而且閉包經過引用該實例或其成員來捕獲該實例，則將在閉包和實例之間建立一個循環引用。 Swift使用捕獲列表來打破這些循環引用。有關更多信息，請參見Strong Reference Cycles for Closures。

4 閉包是引用類型

在上面的示例中，increasingBySeven和increasingByTen是常量，可是這些常量引用的閉包仍然可以增長它們已捕獲的runningTotal變量。這是由於函數和閉包是引用類型。

每當您將函數或閉包分配給常量或變量時，實際上就是在將該常量或變量設置爲對該函數或閉包的引用。在上面的示例中，incrementByTen引用的閉包是常量，而不是閉包自己的內容。

這也意味着，若是將閉包分配給兩個不一樣的常量或變量，則這兩個常量或變量都引用同一閉包。

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// returns a value of 50

incrementByTen()
// returns a value of 60
複製代碼

上面的示例顯示，調用AlsoIncrementByTen與調用crementByTen相同。由於它們都引用相同的閉包，因此它們都遞增並返回相同的運行總計。

5 Escaping 閉包

當閉包做爲函數的參數傳遞給閉包時，閉包被認爲是對函數的轉義，可是在函數返回後會被調用。聲明將閉包做爲其參數之一的函數時，能夠在參數類型以前寫@escaping，以指示容許轉義閉包。

閉包能夠轉義的一種方法是將其存儲在函數外部定義的變量中。例如，許多啓動異步操做的函數都將閉包做爲參數用做完成處理程序。該函數在開始操做後返回，可是直到操做完成後才調用閉包，閉包須要轉義，稍後再調用。例如：

var completionHandlers = [() -> Void]()
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}
複製代碼

someFunctionWithEscapingClosure（_ :)函數將閉包做爲參數，並將其添加到在函數外部聲明的數組中。若是不使用@ecaping標記此函數的參數，則會出現編譯時錯誤。若是self引用類的實例，則引用self的轉義閉包須要特別考慮。用轉義的閉包捕獲self，很容易意外地建立一個循環引用。有關循環引用的信息，請參見自動引用計數。

一般，閉包經過在閉包主體中使用變量來隱式捕獲變量，可是在這種狀況下，您須要明確表示。若是您要捕獲self，請在使用時明確寫出self，或將self包括在閉包的捕獲列表中。明確地寫出self，能夠表達self的意圖，並提醒您確認沒有循環引用。例如，在下面的代碼中，傳遞給someFunctionWithEscapingClosure（_ :)的閉包顯式地引用了self。相比之下，傳遞給someFunctionWithNonescapingClosure（_ :)的閉包是不轉義的閉包，這意味着它能夠隱式引用self。

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"

completionHandlers.first?()
print(instance.x)
// Prints "100"
複製代碼

這是doSomething（）的一個版本，它經過將self包含在閉包的捕獲列表中來捕獲self，而後隱式地引用self：

class SomeOtherClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { [self] in x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}
複製代碼

注意
someFunctionWithEscapingClosure { [self] in x = 100 }這段代碼，在實踐時，Xcode會報錯，須要顯示的引用self，Xcode提示在x前面加上self.

若是self是結構體或枚舉的實例，則始終能夠隱式引用self。可是，當self是結構體或枚舉的實例時，轉義的閉包沒法捕獲對self的可變引用。結構體和枚舉不容許共享可變性，如結構體和枚舉是值類型中所述。

struct SomeStruct {
    var x = 10
    mutating func doSomething() {
        someFunctionWithNonescapingClosure { x = 200 }  // Ok
        someFunctionWithEscapingClosure { x = 100 }     // Error
    }
}
複製代碼

上例中對someFunctionWithEscapingClosure函數的調用是錯誤的，由於它位於mutating方法內部，所以self是可變的。對於結構體來講，這違反了轉義閉包不能捕獲對self的可變引用的規則。

6 自動閉包

自動閉包是一種自動建立的閉包，用於包裝做爲參數傳遞給函數的表達式。它不帶任何參數，調用時將返回包裝在其中的表達式的值。這種語法上的便利性使您能夠經過編寫正則表達式而不是顯式閉包來省略函數參數的花括號。

調用具備自動閉包功能的函數很常見，可是實現這種功能並不常見。例如，assert（condition：message：file：line :)函數會自動閉包其條件和消息參數；僅在調試版本中評估其條件參數，而且僅在condition爲false時評估其message參數。

自動閉包功能可以讓您延遲評估，由於在調用閉包功能以前，內部代碼不會運行。延遲評估對於具備反作用或計算量大的代碼頗有用，由於它使您能夠控制什麼時候評估該代碼。下面的代碼顯示了閉包如何延遲評估。

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// Prints "5"

let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// Prints "5"

print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// Prints "4"
複製代碼

即便customerInInLine數組的第一個元素已由閉包中的代碼刪除，但只有在實際調用閉包以前，才刪除array元素。若是從不調用閉包，則閉包內部的表達式不會被求值，這意味着數組元素不會被刪除。請注意，customerProvider的類型不是String而是（）-> String —一個不帶參數的函數，該函數返回字符串。

將閉包做爲函數的參數傳遞時，您會獲得延遲求值的相同行爲。

// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } )
// Prints "Now serving Alex!"
複製代碼

上面清單中的serve（customer :)函數採用顯式閉包，返回客戶的姓名。下面的serve（customer :)版本執行相同的操做，但不進行顯式閉包，而是經過使用@autoclosure屬性標記其參數類型來進行自動閉包。如今，您能夠像調用String參數而不是使用閉包同樣調用該函數。該參數會自動轉換爲閉包，由於customerProvider參數的類型標記有@autoclosure屬性。

// customersInLine is ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
// Prints "Now serving Ewa!"
複製代碼

注意
過分使用自動閉包功能會使您的代碼難以理解。上下文和函數名稱應明確代表評估被推遲。

若是要容許自動閉包能夠轉義，請同時使用@autoclosure和@escaping屬性。 @escaping屬性在Escaping Closures中進行了描述。

// customersInLine is ["Barry", "Daniella"]
var customerProviders: [() -> String] = []
func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
    customerProviders.append(customerProvider)
}
collectCustomerProviders(customersInLine.remove(at: 0))
collectCustomerProviders(customersInLine.remove(at: 0))

print("Collected \(customerProviders.count) closures.")
// Prints "Collected 2 closures."
for customerProvider in customerProviders {
    print("Now serving \(customerProvider())!")
}
// Prints "Now serving Barry!"
// Prints "Now serving Daniella!"
複製代碼

在上面的代碼中，collectCustomerProviders（_ :)函數將閉包附加到customerProviders數組上，而不是調用做爲其customerProvider參數傳遞給它的閉包。數組在函數範圍以外聲明，這意味着能夠在函數返回後執行數組中的閉包。所以，必須容許customerProvider參數的值轉義該函數的範圍。

總結

這一章節內容剛開始學習的時候有點懵逼，Swift裏的閉包相似於OC裏面的block，與OC裏的block有點差別，下面來總結一下：

閉包是獨立的功能塊，能夠在代碼中傳遞和使用，相似於C和Objective-C中的塊。
閉包表達式語法基本格式：

{ (parameters) -> return type in
    statements
}
複製代碼

如將閉包做爲sorted函數的參數：

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})
複製代碼

因爲body很是短，能夠寫在一行上：

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )
複製代碼

閉包能夠從上下文來推斷類型，因此上面的表達式還能夠簡寫爲：

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
複製代碼

閉包的body裏面是一個單表達式，則能夠隱式返回：

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

複製代碼

Swift裏提供了速記參數名稱來簡化閉包：

reversedNames = names.sorted(by: { $0 > $1 } )
複製代碼

操做符方法更加的簡化了閉包：

reversedNames = names.sorted(by: >)
複製代碼

注意
不是全部的閉包均可以如上面的方式簡寫，要根據調用函數的功能（如sorted函數等）和變量的類型（如字符串、整型等）來判斷是否能夠簡寫。

尾隨閉包：將閉包做爲函數的參數，且閉包表達式很長。如：

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}
//第一種調用方式
someFunctionThatTakesAClosure(closure: {
    // closure's body goes here }) //第二種調用方式 someFunctionThatTakesAClosure() { // trailing closure's body goes here
}
複製代碼

那麼上面的sorted函數的閉包又能夠簡寫爲：

reversedNames = names.sorted() { $0 > $1 }
複製代碼

reversedNames = names.sorted { $0 > $1 }
複製代碼

捕獲值：閉包能夠捕獲外部的常量和變量。閉包能夠從其body內部引用和修改那些常量和變量的值，即便定義常量和變量的原始範圍再也不存在。在Swift中，最簡單的能夠捕獲值的閉包形式是嵌套函數，它寫在另外一個函數的主體內。
閉包是引用類型，要注意循環引用的問題。
Escaping 閉包，也就是轉義閉包，用@escaping標記閉包。閉包能夠轉義的一種方法是將其存儲在函數外部定義的變量中。例如，許多啓動異步操做的函數都將閉包做爲參數用做完成處理程序。該函數在開始操做後返回，可是直到操做完成後才調用閉包，閉包須要轉義，稍後再調用。表達式爲：

func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    //...
}
複製代碼

一般，閉包經過在閉包主體中使用變量來隱式捕獲變量，可是在轉義閉包的狀況下，您須要明確表示。若是您要捕獲self，請在使用時明確寫出self。
若是self是結構體或枚舉的實例，則始終能夠隱式引用self。可是，當self是結構體或枚舉的實例時，轉義的閉包沒法捕獲對self的可變引用。
自動閉包，能夠省略花括號，調用函數時，自動將函數表達式包裝爲閉包，用@autoclosure標記閉包。表達式爲：

func serve(customer customerProvider: @autoclosure () -> String) {
    //...
}
複製代碼

能夠同時使用@escaping和@autoclosure標記：

func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
    customerProviders.append(customerProvider)
}
複製代碼

以上就是閉包的所有內容，須要反覆多看幾遍並敲代碼實踐一下，這樣才更好的理解閉包的使用方法。實話說，本人對於轉義閉包理解的仍是不夠透徹，只是根據官方文檔翻譯大概瞭解了基本的用法，後續若是還有更深的理解的時候，再來補充這部分的內容，這裏說聲抱歉！或者，若是你有更好的理解的話，能夠@我，告訴我一下哈，謝謝啦！

最後，喜歡的童鞋能夠給個👍哦，嘿嘿~

上一章節：函數

下一章節：枚舉