Swift 5.1 (7) - 閉包

級別： ★☆☆☆☆
標籤：「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(知乎)
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的啓動流程
奇舞週刊