Closures：閉包

閉包是獨立的函數(shù)塊，可以在代碼中傳遞和使用。Swift中的閉包類似于C和Objective-C中的block以及其他編程語言中的lambdas(匿名函數(shù))。閉包可以捕獲和存儲上下文中定義的任何常量和變量的引用。
全局函數(shù)和嵌套函數(shù)實際上是閉包的特例。閉包采用以下三種形式之一：

• 全局函數(shù)是具有名稱但不捕獲任何值的閉包。
• 嵌套函數(shù)是具有名稱并且可以從其封閉函數(shù)中捕獲值的閉包。
• Closure表達式是一種未命名的可以從周圍的上下文中捕獲值的閉包，用輕量級語法編寫。

Swift的閉包表達式鼓勵簡潔，因此閉包具備：

• 從上下文中推斷參數(shù)和返回值類型
• 單表達式閉包的隱式返回
• 簡潔的參數(shù)名稱
• 尾隨閉包語法

閉包表達式

嵌套函數(shù)可以將獨立的函數(shù)命名和定義為更大函數(shù)的一部分。Closure表達式優(yōu)化了其中函數(shù)的構(gòu)造，而不用對于函數(shù)進行完整聲明和命名。Closure表達式是一種以簡短，集中的語法編寫內(nèi)聯(lián)閉包的方法。下面將通過sort（by :)方法來闡述Closure表達式所做出的優(yōu)化。
排序方法
sorted（by :)方法，可以根據(jù)我們提供的排序閉包對已知類型的數(shù)組進行排序。該sorted(by:)方法返回一個與舊數(shù)組相同類型和大小的新數(shù)組，新數(shù)組按正確的順序排列。sorted（by :)方法接受一個閉包，該閉包接受與數(shù)組中元素相同類型的兩個參數(shù)，并返回一個Bool值，若返回是true說明第一個值是出現(xiàn)在第二個值之前。若返回是false說明第一個值是出現(xiàn)在第二個值之后。

//排序數(shù)組
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
//定義遞減的排序函數(shù)
func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2//表示從大到小 遞減的順序
}
let newArray = names.sorted(by: backward)
print(newArray)//!< ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

閉包表達式語法
閉包表達式語法具有以下一般形式：

{ (<#parameters#>) -> <#returnType#> in
    <#statements#> 
}

閉包表達式語法中的參數(shù)可以是輸入輸出參數(shù)，但不能具有默認值。可以使用變量(variadic)參數(shù)。元組也可以用作參數(shù)類型和返回類型。
上述示例使用閉包表達式語法內(nèi)聯(lián)編寫排序閉包:

//排序數(shù)組
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let newArray = names.sorted(by: {(s1:String,s2:String)->Bool in
    return s1 > s2
})
print(newArray)//!< ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

對于內(nèi)聯(lián)閉包表達式，參數(shù)和返回類型寫在花括號內(nèi)，而不是在花括號外。閉包的方法體的開頭由in關(guān)鍵字引入。這個關(guān)鍵字表示閉包的參數(shù)和返回類型的定義已經(jīng)完成，閉包的方法體即將開始。
從上下文中推斷類型
因為排序閉包(函數(shù)類型)作為參數(shù)傳遞給方法，所以Swift可以推斷出它的參數(shù)類型以及它返回的值的類型。同時sort（by :)方法是在字符串數(shù)組上調(diào)用的，因此排序閉包是（String，String） - > Bool的函數(shù)類型。因為可以推斷出所有類型，所以排序的閉包表達式（String，String）和Bool類型的返回值也可以不用出現(xiàn)，這意味著可以省略- >，返回值類型和參數(shù)名稱周圍的括號：

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let newArray = names.sorted(by: {s1,s2 in return s1 > s2})
//也可以這樣寫
names.sorted { (s1, s2) -> Bool in
    return s1 > s2
}
print(newArray)//!< ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
print(names)//!< ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

在將閉包作為內(nèi)聯(lián)閉包表達式傳遞給函數(shù)或方法時，始終可以推斷出參數(shù)類型和返回類型。因此，當閉包用作函數(shù)或方法參數(shù)時，永遠不需要以最完整的形式編寫內(nèi)聯(lián)閉包
單表達式閉包的隱式返回
單表達式(s1>s2)閉包可以通過從閉包的聲明中省略return關(guān)鍵字來隱式返回單個表達式的結(jié)果，故上述示例也可寫為：

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let newArray = names.sorted(by: {s1,s2 in s1 > s2})

示例說明：sorted（by :)方法的函數(shù)類型的參數(shù)，清楚地表明了閉包必須返回一個Bool值。因為閉包的方法體中包含了一個返回Bool值的表達式s1> s2，所以沒有歧義，并且可以省略return關(guān)鍵字。
簡寫參數(shù)名稱
簡寫參數(shù)名稱，可通過名稱$ 0，$ 1，$ 2等引用閉包參數(shù)的值。如果在閉包表達式中使用這些簡寫參數(shù)名稱，則可以從閉包表達式中省略閉包的參數(shù)列表，并將通過函數(shù)類型推斷簡寫的參數(shù)名稱的數(shù)量和類型。in關(guān)鍵字也可以省略。

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let newArray = names.sorted(by: {$0 > $1})

操作符方法
上面的閉包表達式實際上有一種更簡短的方式來編寫。Swift的String類型將其大于運算符>的實現(xiàn)，定義為具有兩個String類型參數(shù)的方法，并返回Bool類型的值。這與sorted（by :)方法所需的方法類型完全匹配。因此，可以簡單地傳入運算符>。

let newArray = names.sorted(by: >)

尾隨閉包

如果需要將閉包表達式作為函數(shù)的最終參數(shù)傳遞給函數(shù)，并且閉包表達式很長，則可以將其寫為尾隨閉包。寫法：尾隨閉包寫在函數(shù)調(diào)用的圓括號之后，即使它是函數(shù)的最終參數(shù)。如果尾隨閉包作為函數(shù)的最終參數(shù)，并且定義了相應(yīng)的參數(shù)標簽，在使用尾隨閉包語法時，不能將閉包的參數(shù)標簽寫為函數(shù)調(diào)用的一部分。

//定義一個閉包表達式為函數(shù)最終參數(shù)的函數(shù)
func trailingClosures(parameter:String,block:(_:String)->Void) -> Void {
    block(parameter + " 期待下：trailingClosures")
}
//可以有非尾隨閉包的調(diào)用形式
func blockFunction(_ paramter:String)->Void {
    print(paramter)
}
trailingClosures(parameter: "不是尾隨閉包寫法1", block: blockFunction)
trailingClosures(parameter: "不是尾隨閉包寫法2", block: {(parameter:String)->Void in print(parameter)})
trailingClosures(parameter: "不是尾隨閉包寫法3", block: {(parameter)in print(parameter)})//!< 參數(shù)類型和返回值可以根據(jù)函數(shù)類型得知，故可以省略
//尾隨閉包寫法的調(diào)用形式，block函數(shù)標簽不能出現(xiàn)在圓括號內(nèi)
trailingClosures(parameter: "尾隨閉包的寫法") { (parameter) in
 print(parameter)
}

sorted（by :)的尾隨閉包的寫法。

let newArray = names.sorted(){s1,s2 in s1 > s2}
let newArray = names.sorted(){$0>$1}

若閉包表達式是函數(shù)的唯一參數(shù)，在調(diào)用該函數(shù)時，若采用尾隨閉包的寫法，則不需要再函數(shù)名稱之后寫一對圓括號()

let newArray = names.sorted{s1,s2 in s1 > s2}
let newArray = names.sorted{$0>$1}

值的捕獲

閉包可以從定義它的周圍上下文中捕獲常量和變量。閉包可以在其方法體中引用并修改常量和變量的值，即使定義常量和變量的原始作用域不存在。
在Swift中，一個閉包可以捕獲值的最簡單形式就是嵌套函數(shù)。一個嵌套函數(shù)可以捕獲任何它外圍函數(shù)的參數(shù)也可以捕獲定義在外圍函數(shù)里的常量和變量。

//闡述閉包捕獲值的函數(shù)方法。
func createIncrementer(forIncrese amount:Int) -> ()->Int {
    //定義嵌套函數(shù)外部的變量
    var total = 0
    //定義一個嵌套函數(shù)
    func increase()->Int {
        total += amount
        return total
    }
    //返回此嵌套函數(shù)
    return increase
}

閉包捕獲值的表現(xiàn)分析

let increaseByTen = createIncrementer(forIncrese: 10)//increaseByTen其實是內(nèi)部的嵌套函數(shù)（閉包的一種），捕獲了`createIncrementer`方法的參數(shù)`amount`與方法體中定義的`total`變量。
print(increaseByTen())//!< log:10
print(increaseByTen())//!< log:20
print(increaseByTen())//!< log:30 綜上述`increaseByTen`函數(shù)捕獲了捕獲了`createIncrementer`方法的參數(shù)`amount`與方法體中定義的`total`變量，并在其內(nèi)部持有了外部變量`total`和外部方法參數(shù)`amount`的副本。以至于`increaseByTen`可以每次調(diào)用都能基于`amount`的值，對變量`total`進行遞增，并且返回結(jié)果。
let increaseBySix = createIncrementer(forIncrese: 6)
print(increaseBySix())//!< log:6
print(increaseBySix())//!< log:12
print(increaseBySix())//!< log:18 綜上述：`increaseBySix`是調(diào)用了`createIncrementer`生成的一個`()->Int`類型的常量。在生成的過程中，內(nèi)部的閉包（嵌套函數(shù)）`increase`重新捕獲了外部變量`total`和外部方法參數(shù)`amount`，并返回此方法賦值給了`increaseBySix`，以至于`increaseBySix`和`increaseByTen`具備不同的遞增系數(shù)。本質(zhì)上這是兩個不同的函數(shù)類型的常量。

上述示例中，increaseByTen其實是內(nèi)部的嵌套函數(shù)（閉包的一種）increase。increaseByTen函數(shù)捕獲了createIncrementer方法的參數(shù)amount與方法體中定義的total變量，并在其內(nèi)部持有了increaseByTen函數(shù)捕獲的值的副本。以至于increaseByTen可以每次調(diào)用都能基于amount的值，對變量total進行遞增，并且返回結(jié)果。increaseBySix是調(diào)用了createIncrementer生成的另一個()->Void類型的常量。在生成的過程中，內(nèi)部的閉包（嵌套函數(shù)）increase重新捕獲了外部變量total和外部方法參數(shù)amount，并返回此方法賦值給了increaseBySix，以至于increaseBySix和increaseByTen具備不同的遞增系數(shù)，并且分別進行多次調(diào)用。本質(zhì)上這是兩個不同的函數(shù)類型的常量。

注意：如果值不會被閉包改變，并且閉包創(chuàng)建以后值也不會被改變。Swift可以代替閉包捕獲和存儲值的一個副本。Swift也會參與處理所有不再需要的變量的內(nèi)存管理。

閉包是引用類型

函數(shù)和閉包是引用類型。無論何時將函數(shù)或閉包賦值給常量或變量，實際上都是將該常量或變量設(shè)置為對函數(shù)或閉包的引用。意味著如果為兩個不同的常量或變量分配同一個閉包，那么這兩個常量或變量都將引用的是相同的閉包。

let alsoIncreaseByTen = increaseByTen //!< 引用傳遞
print(alsoIncreaseByTen())//!< log:40
let alsoIncreaseByTen1 = increaseByTen
print(alsoIncreaseByTen1())//!< log:50

上述示例中可以看出，函數(shù)或閉包是引用類型，常量之間的賦值，其實是引用的傳遞，不管是alsoIncreaseByTen還是alsoIncreaseByTen1都引用的是同一個函數(shù)指針。因此調(diào)用結(jié)果會持續(xù)遞增。

逃逸閉包

閉包作為函數(shù)參數(shù)進行傳遞，但是該閉包并未在函數(shù)返回前調(diào)用，而是在函數(shù)返回后才被調(diào)用，則這個閉包被稱為逃逸了。當我們聲明一個以閉包作為參數(shù)之一的函數(shù)時，我們可以在該閉包參數(shù)的類型之前書寫@escaping來表示該閉包允許逃逸。即：允許該閉包在函數(shù)結(jié)束后仍然可以被調(diào)用。
當一個函數(shù)需要用到異步操作回調(diào)的時候需要使用逃逸閉包。
實現(xiàn)閉包逃逸的一種途徑是通過將該閉包存儲到定義在函數(shù)外面的變量中，稍后再去調(diào)用。我們將使用這種方式，描述閉包逃逸的場景。

class escapeClosure: NSObject {
    //聲明一個閉包類型的數(shù)組
    var closureArray : [(String)->Void] = []
    override init() {
        super.init()
        
    }
    //模仿閉包逃逸:寫完 closureArray.append編譯器檢測到時逃逸閉包提示添加@escaping
    func escapeClosures(title:String,handle:@escaping (String)->Void){
        closureArray.append(handle)
    }
    //類方法
    static func startEscape(){
       let escapeObject = escapeClosure()
       escapeObject.escapeClosures(title: "場景1") { (s1) in
            print("場景1"+s1)//!< 場景1逃逸閉包1被調(diào)用了
        }
        escapeObject.escapeClosures(title: "場景2") { (s1) in
            print("場景2"+s1)//!< 場景2逃逸閉包2被調(diào)用了
        }
        //使用迭代器進行下標和元素的同時遍歷
        for (index,obj) in  escapeObject.closureArray.enumerated() {
            obj("逃逸閉包\(index+1)被調(diào)用了")
        }
    }
}
//調(diào)用
escapeClosure.startEscape()//!< 場景1逃逸閉包1被調(diào)用了 場景2逃逸閉包2被調(diào)用了

自動閉包：Autoclosures

autoclosure是一個被自動創(chuàng)建的閉包，用于包裝作為參數(shù)傳遞給函數(shù)的表達式。該表達式被自動創(chuàng)建為：不含參數(shù)，返回值省略（根據(jù)表達式的返回值決定）in關(guān)鍵字省略，方法體中只含表達式的閉包。 當該函數(shù)被調(diào)用時，自動閉包會返回表達式的值。我們可以通過在函數(shù)類型前使用關(guān)鍵字@autoclosure把自動閉包外圍的花括號{}都給去掉。但是重點是使用@autoclosure關(guān)鍵字只限于修飾參數(shù)中的閉包，并且該閉包的類型可以有返回值，但絕對不能有參數(shù)。若對@autoclosure關(guān)鍵字搞點事情修飾下不是參數(shù)的閉包，會發(fā)現(xiàn)報錯：'@autoclosure' may only be used on parameters。修飾下帶有參數(shù)的閉包，會發(fā)現(xiàn)報錯：Argument type of @autoclosure parameter must be '()'。

var nameArray = ["趙云","關(guān)羽","張飛","劉備"]
//閉包參數(shù)為空 被省略 返回值是String類型由`nameArray.remove(at: 0)`的返回值決定 故省略，同時省略了`in`關(guān)鍵字
let removeClosure = {
    nameArray.remove(at: 0)
}
print("調(diào)用`removeClosure`移除之前，數(shù)組`nameArray`的個數(shù)：\(nameArray.count)。調(diào)用`removeClosure`之后移除了字符串：\(removeClosure()) ，數(shù)組`nameArray`的個數(shù)變?yōu)椋篭(nameArray.count)。綜上述可以看出自動閉包允許延遲調(diào)用，因為在調(diào)用閉包之前，內(nèi)部代碼不會運行")

上述示例中，調(diào)用removeClosure移除數(shù)組首元素之前，數(shù)組nameArray的個數(shù)：4。調(diào)用removeClosure之后移除了字符串：趙云 ，數(shù)組nameArray的個數(shù)變?yōu)椋?。綜上述可以看出自動閉包允許延遲調(diào)用，因為在調(diào)用閉包之前，內(nèi)部代碼不會運行。

//延遲調(diào)用的另一種形式，定義個擬合自動閉包的函數(shù)類型作為參數(shù)的函數(shù)。先定義閉包，隨后在函數(shù)體內(nèi)調(diào)用獲取值。
static func unknownOperate(operation:()->String) -> Void {
    print("閉包作為參數(shù),輸出的刪除的數(shù)組的字符串:\(operation())")//<!閉包作為參數(shù),輸出的刪除的數(shù)組的字符串:趙云
}
//將閉包作為參數(shù)傳遞給函數(shù)時，在函數(shù)中進行數(shù)據(jù)元素移除的操作
escapeClosure.unknownOperate { () -> String in
    nameArray.remove(at: 0)
}
//更簡化的形式
escapeClosure.unknownOperate {nameArray.remove(at: 0)}

使用關(guān)鍵字@autoclosure標記閉包參數(shù)為自動閉包類型的。調(diào)用函數(shù)時，傳遞閉包的實參時，可以像傳String類型的參數(shù)一樣而不是閉包那樣傳遞。

//定義一個自動閉包的形式
static func autoClosure(operation: @autoclosure ()->String){
    print("自動閉包作為參數(shù),輸出的刪除的數(shù)組的字符串:\(operation())")
}
//調(diào)用很神奇啊，但也會讓人很蒙 有木有
 escapeClosure.autoClosure(operation: nameArray.remove(at: 0))

注意：過度使用autoclosures會使我們的代碼難以理解。上下文和函數(shù)名稱應(yīng)該明確表示該閉包的調(diào)用被推遲了。
自動閉包同時也允許逃逸。需要同時使用@autoclosure和@escaping屬性。

//定義存儲自動閉包類型的數(shù)組變量
var autoclosureArray : [()->String] = []
//自動閉包實現(xiàn)逃逸
func autoclosureAndEscape(handle: @autoclosure @escaping ()->String) -> Void {
    autoclosureArray.append(handle)
}
//執(zhí)行自動閉包逃逸操作
static func doAutoclosureAndEscape(){
    var nameArray = ["我是來自數(shù)組的可逃逸的自動閉包"]
    //實例化對象
    let escapeObj = escapeClosure()
    escapeObj.autoclosureAndEscape(handle: "我是可逃逸的自動閉包")
    escapeObj.autoclosureAndEscape(handle: nameArray.remove(at: 0))
    //逃逸閉包的調(diào)用，在函數(shù)返回后
    for (index,handle) in escapeObj.autoclosureArray.enumerated() {
        print("\(handle()):\(index)號")
    }
}
//調(diào)用
escapeClosure.doAutoclosureAndEscape()//!< 自動閉包逃逸
/*控制臺輸出：
我是可逃逸的自動閉包：0號
我是來自數(shù)組的可逃逸的自動閉包：1號
*/

參考資料：
swift 5.1官方編程指南