級別： ★☆☆☆☆
標簽：「iOS」「Swift 5.1」「閉包」「逃逸閉包」「尾隨閉包」
作者： 沐靈洛
審校： QiShare團隊

Closures：閉包

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

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

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

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

閉包表達式

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

//排序數組
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
//定義遞減的排序函數
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#> 
}

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

//排序數組
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"]

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

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"]

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

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

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

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

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

let newArray = names.sorted(by: >)

尾隨閉包

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

//定義一個閉包表達式為函數最終參數的函數
func trailingClosures(parameter:String,block:(_:String)->Void) -> Void {
    block(parameter + " 期待下：trailingClosures")
}
//可以有非尾隨閉包的調用形式
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)})//!< 參數類型和返回值可以根據函數類型得知，故可以省略
//尾隨閉包寫法的調用形式，block函數標簽不能出現在圓括號內
trailingClosures(parameter: "尾隨閉包的寫法") { (parameter) in
 print(parameter)
}

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

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

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

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

值的捕獲

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

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

閉包捕獲值的表現分析

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

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

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

閉包是引用類型

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

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

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

逃逸閉包

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

class escapeClosure: NSObject {
    //聲明一個閉包類型的數組
    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被調用了
        }
        escapeObject.escapeClosures(title: "場景2") { (s1) in
            print("場景2"+s1)//!< 場景2逃逸閉包2被調用了
        }
        //使用迭代器進行下標和元素的同時遍歷
        for (index,obj) in  escapeObject.closureArray.enumerated() {
            obj("逃逸閉包\(index+1)被調用了")
        }
    }
}
//調用
escapeClosure.startEscape()//!< 場景1逃逸閉包1被調用了 場景2逃逸閉包2被調用了

自動閉包：Autoclosures

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

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

上述示例中，調用removeClosure移除數組首元素之前，數組nameArray的個數：4。調用removeClosure之后移除了字符串：趙云 ，數組nameArray的個數變為：3。綜上述可以看出自動閉包允許延遲調用，因為在調用閉包之前，內部代碼不會運行。

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

使用關鍵字@autoclosure標記閉包參數為自動閉包類型的。調用函數時，傳遞閉包的實參時，可以像傳String類型的參數一樣而不是閉包那樣傳遞。

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

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

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

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

關注我們的途徑有：
QiShare(簡書)
QiShare(掘金)
QiShare(知乎)
QiShare(GitHub)
QiShare(CocoaChina)
QiShare(StackOverflow)
QiShare(微信公眾號)

推薦文章：
用SwiftUI給視圖添加動畫
用SwiftUI寫一個簡單頁面
iOS 控制日志的開關
iOS App中可拆卸一個framework的兩種方式
自定義WKWebView顯示內容（一）
Swift 5.1 (6) - 函數
Swift 5.1 (5) - 控制流
Xcode11 新建工程中的SceneDelegate
iOS App啟動優化（二）—— 使用“Time Profiler”工具監控App的啟動耗時
iOS App啟動優化（一）—— 了解App的啟動流程
奇舞周刊