Swift-- 閉包

閉包是自包含的功能塊，能夠在代碼中傳遞和使用。Swift閉包與c和oc中的block相似，其餘語言用lambdas。

閉包能夠獲取和存儲指向在閉包內部定義的任何常量和變量，這就是所謂的封閉常量和變量，swift爲你處理全部的捕捉的內存管理。

注意：若是你對捕捉的概念不熟悉，不用擔憂，在Capture Value中會詳情的說明。

 

已經在Function中介紹的全局方法和嵌套方法，其實是Closures的一箇中特殊例子。Closures採用三種形式之一：

• 全局函數是一種 有個名字可是沒有捕獲任何值的閉包函數。
• 嵌套函數是一種 有一個函數名而且能夠從他們的閉包函數中獲取到值的閉包。
• 閉包表達式是使用輕量級語法編寫的閉包，能夠從周圍環境捕獲值。

Swift的閉包表達式有一種乾淨、清晰的風格，在常見的場景中使用了鼓勵簡短、無規則的語法的優化。這些優化包括：

從上下文推斷參數和返回值類型

來自間單表達式閉包的隱式返回

速記參數名稱

後關閉的語法

 

1.閉包的表達式

嵌套函數，是一種方便命名和定義自包函數塊的方法，做爲一個大函數的一部分。然而，有時候編寫一個間斷的不帶完整的聲明和命名的函數結構是頗有用的，尤爲是在須要用函數做爲一個或者多個函數或者方法的參數的時候。

閉包表達式一種是簡潔、集中的語法編寫的內聯閉包的方法。閉包表達式提供了一些語法優化，能夠在短表單中編寫閉包，而不會失去清晰或意圖。下面閉包表達式的例子說明了這些優化，經過從新定義sorted(by:)函數，每一個表達式都以更簡潔的方式表達相同的功能。

（1）排序方法

Swift標準庫提供一個sroted（by：）的方法，基於你提供的排序閉包輸出，給一個已知類型的數組排序。一旦這個排序完成，sorted（by：）方法返回一個新的按照正確順序排過序的數組，數組的類型和大小都與舊的數組一致。原始的數組不會被修改。

下面閉包表達式的例子用sorted(by:)方法爲一個字符串數組按照字母順序排序。排序(經過:)方法接受一個閉包，該閉包接受與數組內容相同類型的兩個參數，並返回Bool值，以肯定一旦值被排序，第一個值是否應該出如今第二個值以前或以後。若是第一個值出如今第二個值以前，那麼排序結束須要返回true，不然將返回false。

這個例子是對字符串數組進行排序的，所這個排序的閉包須要函數類型爲(String, String) -> Bool.

提供排序閉包的一個方法是寫一個普通正確類型的函數，把這個函數對坐sorted(by:)方法的參數傳遞進去。

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
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前面。

（2）閉包表達式的語法

{ (parameters) -> return type in
    statements
}

 在閉包表達式中的語法中，參數能夠用輸入輸出參數，但他們不能有默認的值。當你命名參數變量的時候，變量參數可使用，元組也能夠做爲閉包表達式的參數。

前面提到的 backward(_:_:)函數能夠用下面的方法來表示：

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

 注意的是，在函數 backward(_:_:)的聲明與內聯閉包函數聲明參數和返回值類型是同樣的。這個兩個例子中，都寫成：(s1: String, s2: String) -> Bool。然而，在內聯函數閉包表達中，參數和返回值都寫在花括號內，而不是外部。

閉包函數體以「in」關鍵字爲開始。這個關鍵字表示這個閉包的參數和返回值類型已經完成，而閉包體剛剛開始。

若是閉包體很短，能夠寫在同一行裏：

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

 （2）從上下文中推斷類型

由於閉包函數做爲一個參數傳給一個方法，Swift能夠推斷這個參數的類型以及這個返回值的類型。sprted(by:)這個方法在字符串數組調用的時候，它的參數必須（String, String）->Bool 的函數類型。意味着（String, String）和  Bool 類型不須要做爲閉包表達式定義的一部分。由於全部的類型都是推斷，返回箭頭(->)和參數名字的括號也能夠省略。

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

 當將閉包傳給一個函數或者方法做爲內聯閉包表達時，一般都是能夠推斷出參數的類型和返回值類型的。

固然，若是你想的話，仍然讓你的類型清晰一點，若是爲了你的代碼讀起來避免模凌兩可的時候仍是鼓勵你們那麼坐的。

（3）從簡單閉包表達式返回一個精確的值

簡單表達式的閉包，在他們的表達式聲明中省略return關鍵字，也能夠精確返回一個結果。

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

 這裏，sorted(by:)方法的參數的函數類型讓這個方法很清晰明白，這個閉包確定返回一個Bool值。

（4）縮短參數名

SSwift自動爲內聯閉包提供了簡短的參數名稱，能夠用來引用閉包參數的值，名稱爲$ 0、$ 一、$ 2，等等。

若是你在閉包表達式中用這些短參數的話，你能夠在定義閉包的時候，省略參數列表。短參數的名稱的個數和類型能夠從指定的參數類型來推斷出來。in關鍵字也能夠被忽略，由於閉包表達式徹底由它的閉包體組成。

reversedNames = names.sorted(by: { $0 > $1 } )

 這裏，$0,$1引用了閉包第一個和第二String類型的參數。

（5）操做方法

上面的閉包閉包表達式中還有一個更簡短的方法。Swift的String類型定義了比操做符（>）作爲一種具備兩個字符串類型的參數和返回一個bool類型值的方法。所以，你能夠簡單地傳一個比操做符，Swift會自動推斷出你想用它的string-specific功能。

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
}

 在閉包表達式語法部分中的字符串排序閉包，能夠寫在sroted（by：）方法括號外面做爲尾隨閉包：

reversedNames = names.sorted() { $0 > $1 }

 若是一個閉包表達式做爲一個函數或者方法的惟一參數，並且你提供的這個表達式做爲尾隨閉包，則當你調用這個方法的時候，你不須要在函數和方法名的後面寫（）。

reversedNames = names.sorted { $0 > $1 }

 當閉包比較長以致於在內聯函數中一行寫不下時，用尾隨閉包是至關有用的。例如，Swift 的數組類型有個map(_:)方法，它用閉包表達式做爲惟一的參數。數組中的每一個元素都會調用一次這個閉包，而且爲每一個元素返回一個可替代的值（多是其餘類型的）。映射的性質和返回值的類型留給閉包來指定。

在要求爲數組的每一個元素提供閉包後，map(_:)方法返回一個包含全部新映射值的數組，順序與原數據的順序一致。

這裏就是說明，你若是用一個帶有尾隨閉包的map(_:)方法把Int數組轉成String字符的數組。用數組[16,58,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]

 上面的代碼建立了一個關於數字和數字英文名的字典類型的映射。還定義了一個用於轉化成字符串的數字數組。

你如今能夠用numbers數組去建立一個String類型值的數組，經過給數組map(_:)方法的尾隨閉包傳入一個閉包表達式。

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 是有閉包參數number初始化的值，因此這個值能夠在閉包體中修改。（方法和閉包的參數始終都是常量）。閉包表達式也制定了一個返回類型String，爲了代表在映射輸出的數組中用這個類型排序。

這個閉包表達式被調用的時候會構建一個output的字符串。它經過使用剩餘的運算符來計算最後一個數字(number % 10)，而後用這個數字在digitNames的字典中，查找是否有匹配的字符串。

注意：對digitNames字典的下標的調用後面跟着一個感嘆號(!)，由於字典子腳本返回一個可選的值，以代表若是鍵不存在，字典查找就會失敗。在上面的示例中，能夠保證number % 10始終是數字字典的一個有效的下標鍵，所以使用感嘆號來強制解壓存儲在下標可選返回值中的字符串值。

從digitNames字典中取得的字符串會添加在output前面，有效的構建了這個數字轉換後的字符串。

變量number被10整除，由於它是一個整數，它在除法中是圓形的，因此，16變成了1，58變成了5，510變成了51.

這個過程一直重複知道這個number等於0，與此同時，output字符串也從閉包中返回，並添加到了map(_:) 方法的輸出數組中。

在上述尾隨閉包語法中，當函數的閉包一提供，就能夠封裝閉包功能，不須要在map(_:)方法的()內部封裝整個閉包。

3.捕獲值

一個閉包能夠根據它定義的上下文來獲取一個常量和變量。閉包能夠在它的閉包體中引用和修改這些常量和變量的值，即便在最初定義的常量和變量的做用域再也不存在。

在Swift中，能夠捕獲值的閉包最簡單形式是嵌套函數，在閉包體中編寫另一個方法。一個嵌套函數能夠獲取到在它外面函數的參數，而且能夠獲取這些外函數定義的常量和變量。

這個例子就是一個叫makeIncrementer函數，它包含了一個嵌套函數incrementer。這個嵌套函數incrementer()函數能夠從上下文中獲取到兩個值runningTotal和amount。獲取到這兩個值後，makeIncrementer將incrementer做爲閉包返回，每次調用時遞增。

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

 makeIncrementer的返回類型是()->Int,這意味着它返回的是一個函數，而不是一個值。這個返回的函數沒有參數，每次調用的時候返回Int值。

makeIncrementer(forIncrement:)函數定義一個runningTotal的整型變量，存儲incrementer中正在運行總數的值，而且返回。這個整數初始化爲0.

makeIncrementer(forIncrement:)函數有一個Int類型的參數，參數標籤爲forIncrement,參數名爲amount。當調用incrementer這個方法時，傳入參數指定runningTotal每次返回時增長了多少。在makeIncrementer函數中定義個了一個嵌套函數叫作incrementer，這個嵌套函數的做用是增長。這個嵌套函數只是簡單地把amount與runningTotal的值相加，並返回相加的結果。

若是單獨考慮這個嵌套函數，會以爲很奇怪：

func incrementer() -> Int {
    runningTotal += amount
    return runningTotal
}

 incrementer()函數沒有任何的參數，它仍然在閉包體中引用runningTotal和amount。它從上下文函數中捕獲了runnintTotal和amoun值，並在本身的函數體中使用了它們。經過引用獲取值能夠確保runningTotal和amount不會消失當makeIncrementer調用結束後，並且確保下一次incrementer函數調用的時候，runningTotal是有效的。

注意：

做爲一種優化，若是不經過閉包來改變值，那麼Swift能夠捕獲並存儲一個值的副本，若是在建立了閉包以後值沒有發生突變，則能夠保存該值的副本。

Swift還處理在再也不須要時處理變量的全部內存管理。

下面是makeIncrementer的調用：

let incrementByTen = makeIncrementer(forIncrement: 10)

這個示例設置了一個名爲incrementByTen的常量，以引用一個遞增函數，每次調用它時，它都會爲它的runningTotal變量增長10個變量若是屢次調用這個函數，那麼結果以下：

incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30

 若是你再建立一個遞增函數，它將有它本身的存儲引用到一個新的、獨立的runningTotal變量:

let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7

 再一次調用incrementerByTen，會繼續增長它本身的runningTotal變量，不會影響incrementBySeven的變量。

incrementByTen()
// returns a value of 40

 注意：若是你給一個類對象設置了閉包屬性，並且這個閉包經過引用這個實例或者它的成員獲取到這個實例，你會在閉包和實例中建立強的循環引用。

 

4.閉包是引用類型

上述的例子中，incrementBySeven和incrementByTen是常量，可是閉包常量的引用依然能夠增長捕獲到的runningTotal變量的值。這是由於函數和閉包都是引用類型。

不管何時，你分配一個函數或者閉包給一個常量或者變量，你其實是把這個常量和變量指向了函數或者閉包。上面的例子，incrementByTen指的是一個常量，不是指閉包的內容。

它意味着若是你分配一個閉包給兩個不一樣的變量或者常量，這兩個常量或者變量指向相同的閉包：

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

 5.逃離閉包

若是一個閉包當成一個函數的參數傳入時，這個閉包稱之爲逃離函數，可是它是在函數返回時才調用的。當你聲明一個函數，函數的其中一個參數是閉包，你能夠在參數類型前面寫上「@escaping」代表閉包是容許逃離的。

還有一個閉包能夠escape的方法是：經過存儲在一個定義在函數以外的變量上。例如，許多啓動異步操做的函數採用閉包參數做爲完成處理程序。這個函數在操做開始時返回，可是閉包不會被調用知道這個操做完成--閉包須要轉義，稍後調用。例如：

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

 someFunctionWithEscapingClosure(_:)函數參數類型是閉包，並把它添加到在函數外的一個數組中。若是你不在函數的參數上標記「 @escaping」，會提示編輯時錯誤。

經過@escape來控制閉包意味着您必須在閉包中顯式地引用自顯。例如,在下面的代碼中,閉包傳遞給someFunctionWithEscapingClosure(_:)是一種escape closure,這意味着它須要顯式地引用self。相比之下,閉包傳遞給someFunctionWithNonescapingClosure(_:)是一個nonescaping closure,這意味着它能夠指自我暗示。

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"

 

6.自動閉包

自動閉包是一個閉包，它是自動建立的、用來做爲函數參數的表達式。調用的時候，不須要傳入任何的參數，返回這個表達式的值。這種句法方即可以讓您在函數的參數周圍省略大括號，而不是顯式的closur，而是編寫一個正常的表達式。

經過自動閉包調用函數是很正常的，可是實現這種方法並不常見。例如： assert(condition:message:file:line:)函數用自動閉包做爲condition和message的參數，condition這個參數只有在編譯debug時才調用，而message只有在condition爲false時才調用。

一個自動閉包讓你延遲評估，由於內部代碼不會執行知道你調用這個閉包。延遲評估對有反作用或者計算費用很昂貴的代碼頗有用，由於它讓你控制代碼何時評估。下面的代碼顯示了一個閉包若是延遲評估。

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"

 儘管customersInLine數組的第一個元素在閉包的內部已經被移除，可是數組的元素並不會真的移除粗肥閉包真的被調用了。若是閉包沒有被調用，這個閉包的表達式不會被評估，也就是說數組中的元素永遠不會被移除。注意，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做爲閉包。

注意：過分使用自動閉包會讓你代碼看起來費力。

若是你想用一個自動閉包來容許逃逸，用 @autoclosure and @escaping屬性。

// 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!"