閉包（Closures）

閉包是自包含的函數(shù)代碼塊，可以在代碼中被傳遞和使用。Swift 中的閉包與 C 和 Objective-C 中的代碼塊（blocks）以及其他一些編程語言中的 lambdas 函數(shù)比較相似。

閉包可以捕獲和存儲其所在上下文中任意常量和變量的引用。這就是所謂的閉合并包裹著這些常量和變量，俗稱閉包。Swift 會為您管理在捕獲過程中涉及到的所有內(nèi)存操作。

注意：如果您不熟悉捕獲（capturing）這個概念也不用擔心，您可以在 值捕獲 章節(jié)對其進行詳細了解。

在函數(shù) 章節(jié)中介紹的全局和嵌套函數(shù)實際上也是特殊的閉包，閉包采取如下三種形式之一：

• 全局函數(shù)是一個有名字但不會捕獲任何值的閉包
• 嵌套函數(shù)是一個有名字并可以捕獲其封閉函數(shù)域內(nèi)值的閉包
• 閉包表達式是一個利用輕量級語法所寫的可以捕獲其上下文中變量或常量值的匿名閉包

Swift 的閉包表達式擁有簡潔的風(fēng)格，并鼓勵在常見場景中進行語法優(yōu)化，主要優(yōu)化如下：

• 利用上下文推斷參數(shù)和返回值類型
• 隱式返回單表達式閉包，即單表達式閉包可以省略return關(guān)鍵字
• 參數(shù)名稱縮寫
• 尾隨（Trailing）閉包語法

閉包表達式（Closure Expressions）

嵌套函數(shù) 是一個在較復(fù)雜函數(shù)中方便進行命名和定義自包含代碼模塊的方式。當然，有時候撰寫小巧的沒有完整定義和命名的類函數(shù)結(jié)構(gòu)也是很有用處的，尤其是在您處理一些函數(shù)并需要將另外一些函數(shù)作為該函數(shù)的參數(shù)時。

閉包表達式是一種利用簡潔語法構(gòu)建內(nèi)聯(lián)閉包的方式。閉包表達式提供了一些語法優(yōu)化，使得撰寫閉包變得簡單明了。下面閉包表達式的例子通過使用幾次迭代展示了sorted函數(shù)定義和語法優(yōu)化的方式。每一次迭代都用更簡潔的方式描述了相同的功能。

sorted 函數(shù)（The Sorted Function）

Swift 標準庫提供了sorted函數(shù)，會根據(jù)您提供的基于輸出類型排序的閉包函數(shù)將已知類型數(shù)組中的值進行排序。一旦排序完成，函數(shù)會返回一個與原數(shù)組大小相同的新數(shù)組，該數(shù)組中包含已經(jīng)正確排序的同類型元素。

下面的閉包表達式示例使用sorted函數(shù)對一個String類型的數(shù)組進行字母逆序排序，以下是初始數(shù)組值：

    let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

sorted函數(shù)需要傳入兩個參數(shù)：

• 已知類型的數(shù)組
• 閉包函數(shù)，該閉包函數(shù)需要傳入與數(shù)組類型相同的兩個值，并返回一個布爾類型值來告訴sorted函數(shù)當排序結(jié)束后傳入的第一個參數(shù)排在第二個參數(shù)前面還是后面。如果第一個參數(shù)值出現(xiàn)在第二個參數(shù)值前面，排序閉包函數(shù)需要返回true，反之返回false。

該例子對一個String類型的數(shù)組進行排序，因此排序閉包函數(shù)類型需為(String, String) -> Bool。

提供排序閉包函數(shù)的一種方式是撰寫一個符合其類型要求的普通函數(shù)，并將其作為sort函數(shù)的第二個參數(shù)傳入：

    func backwards(s1: String, s2: String) -> Bool {
        return s1 > s2
    }
    var reversed = sorted(names, backwards)
    // reversed 為 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

如果第一個字符串 (s1) 大于第二個字符串 (s2)，backwards函數(shù)返回true，表示在新的數(shù)組中s1應(yīng)該出現(xiàn)在s2前。對于字符串中的字符來說，“大于” 表示 “按照字母順序較晚出現(xiàn)”。這意味著字母"B"大于字母"A"，字符串"Tom"大于字符串"Tim"。其將進行字母逆序排序，"Barry"將會排在"Alex"之前。

然而，這是一個相當冗長的方式，本質(zhì)上只是寫了一個單表達式函數(shù) (a > b)。在下面的例子中，利用閉合表達式語法可以更好的構(gòu)造一個內(nèi)聯(lián)排序閉包。

閉包表達式語法（Closure Expression Syntax）

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

    { (parameters) -> returnType in
        statements
    }

閉包表達式語法可以使用常量、變量和inout類型作為參數(shù)，不提供默認值。也可以在參數(shù)列表的最后使用可變參數(shù)。元組也可以作為參數(shù)和返回值。

下面的例子展示了之前backwards函數(shù)對應(yīng)的閉包表達式版本的代碼：

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

需要注意的是內(nèi)聯(lián)閉包參數(shù)和返回值類型聲明與backwards函數(shù)類型聲明相同。在這兩種方式中，都寫成了(s1: String, s2: String) -> Bool。然而在內(nèi)聯(lián)閉包表達式中，函數(shù)和返回值類型都寫在大括號內(nèi)，而不是大括號外。

閉包的函數(shù)體部分由關(guān)鍵字in引入。該關(guān)鍵字表示閉包的參數(shù)和返回值類型定義已經(jīng)完成，閉包函數(shù)體即將開始。

因為這個閉包的函數(shù)體部分如此短以至于可以將其改寫成一行代碼：

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

這說明sorted函數(shù)的整體調(diào)用保持不變，一對圓括號仍然包裹住了函數(shù)中整個參數(shù)集合。而其中一個參數(shù)現(xiàn)在變成了內(nèi)聯(lián)閉包（相比于backwards版本的代碼）。

根據(jù)上下文推斷類型（Inferring Type From Context）

因為排序閉包函數(shù)是作為sorted函數(shù)的參數(shù)進行傳入的，Swift可以推斷其參數(shù)和返回值的類型。sorted期望第二個參數(shù)是類型為(String, String) -> Bool的函數(shù)，因此實際上String,String和Bool類型并不需要作為閉包表達式定義中的一部分。因為所有的類型都可以被正確推斷，返回箭頭 (->) 和圍繞在參數(shù)周圍的括號也可以被省略：

    reversed = sorted(names, { s1, s2 in return s1 > s2 } )

實際上任何情況下，通過內(nèi)聯(lián)閉包表達式構(gòu)造的閉包作為參數(shù)傳遞給函數(shù)時，都可以推斷出閉包的參數(shù)和返回值類型，這意味著您幾乎不需要利用完整格式構(gòu)造任何內(nèi)聯(lián)閉包。

單表達式閉包隱式返回（Implicit Return From Single-Expression Clossures）

單行表達式閉包可以通過隱藏return關(guān)鍵字來隱式返回單行表達式的結(jié)果，如上版本的例子可以改寫為：

    reversed = sorted(names, { s1, s2 in s1 > s2 } )

在這個例子中，sorted函數(shù)的第二個參數(shù)函數(shù)類型明確了閉包必須返回一個Bool類型值。因為閉包函數(shù)體只包含了一個單一表達式 (s1 > s2)，該表達式返回Bool類型值，因此這里沒有歧義，return關(guān)鍵字可以省略。

參數(shù)名稱縮寫（Shorthand Argument Names）

Swift 自動為內(nèi)聯(lián)函數(shù)提供了參數(shù)名稱縮寫功能，您可以直接通過$0,$1,$2來順序調(diào)用閉包的參數(shù)。

如果您在閉包表達式中使用參數(shù)名稱縮寫，您可以在閉包參數(shù)列表中省略對其的定義，并且對應(yīng)參數(shù)名稱縮寫的類型會通過函數(shù)類型進行推斷。in關(guān)鍵字也同樣可以被省略，因為此時閉包表達式完全由閉包函數(shù)體構(gòu)成：

    reversed = sorted(names, { $0 > $1 } )

在這個例子中，$0和$1表示閉包中第一個和第二個String類型的參數(shù)。

運算符函數(shù)（Operator Functions）

實際上還有一種更簡短的方式來撰寫上面例子中的閉包表達式。Swift 的String類型定義了關(guān)于大于號 (>) 的字符串實現(xiàn)，其作為一個函數(shù)接受兩個String類型的參數(shù)并返回Bool類型的值。而這正好與sorted函數(shù)的第二個參數(shù)需要的函數(shù)類型相符合。因此，您可以簡單地傳遞一個大于號，Swift可以自動推斷出您想使用大于號的字符串函數(shù)實現(xiàn)：

    reversed = sorted(names, >)

更多關(guān)于運算符表達式的內(nèi)容請查看 運算符函數(shù)。

尾隨閉包（Trailing Closures）

如果您需要將一個很長的閉包表達式作為最后一個參數(shù)傳遞給函數(shù)，可以使用尾隨閉包來增強函數(shù)的可讀性。尾隨閉包是一個書寫在函數(shù)括號之后的閉包表達式，函數(shù)支持將其作為最后一個參數(shù)調(diào)用。

    func someFunctionThatTakesAClosure(closure: () -> ()) {
        // 函數(shù)體部分
    }

    // 以下是不使用尾隨閉包進行函數(shù)調(diào)用
    someFunctionThatTakesAClosure({
        // 閉包主體部分
    })

    // 以下是使用尾隨閉包進行函數(shù)調(diào)用
    someFunctionThatTakesAClosure() {
        // 閉包主體部分
    }

注意：如果函數(shù)只需要閉包表達式一個參數(shù)，當您使用尾隨閉包時，您甚至可以把()省略掉。

在上例中作為sorted函數(shù)參數(shù)的字符串排序閉包可以改寫為：

    reversed = sorted(names) { $0 > $1 }

當閉包非常長以至于不能在一行中進行書寫時，尾隨閉包變得非常有用。舉例來說，Swift 的Array類型有一個map方法，其獲取一個閉包表達式作為其唯一參數(shù)。數(shù)組中的每一個元素調(diào)用一次該閉包函數(shù)，并返回該元素所映射的值(也可以是不同類型的值)。具體的映射方式和返回值類型由閉包來指定。

當提供給數(shù)組閉包函數(shù)后，map方法將返回一個新的數(shù)組，數(shù)組中包含了與原數(shù)組一一對應(yīng)的映射后的值。

下例介紹了如何在map方法中使用尾隨閉包將Int類型數(shù)組[16,58,510]轉(zhuǎn)換為包含對應(yīng)String類型的數(shù)組["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]

如上代碼創(chuàng)建了一個數(shù)字位和它們名字映射的英文版本字典。同時定義了一個準備轉(zhuǎn)換為字符串的整型數(shù)組。

您現(xiàn)在可以通過傳遞一個尾隨閉包給numbers的map方法來創(chuàng)建對應(yīng)的字符串版本數(shù)組。需要注意的時調(diào)用numbers.map不需要在map后面包含任何括號，因為其只需要傳遞閉包表達式這一個參數(shù)，并且該閉包表達式參數(shù)通過尾隨方式進行撰寫：

    let strings = numbers.map {
        (var number) -> String in
        var output = ""
        while number > 0 {
            output = digitNames[number % 10]! + output
            number /= 10
        }
        return output
    }
    // strings 常量被推斷為字符串類型數(shù)組，即 String[]
    // 其值為 ["OneSix", "FiveEight", "FiveOneZero"]

map在數(shù)組中為每一個元素調(diào)用了閉包表達式。您不需要指定閉包的輸入?yún)?shù)number的類型，因為可以通過要映射的數(shù)組類型進行推斷。

閉包number參數(shù)被聲明為一個變量參數(shù)（變量的具體描述請參看常量參數(shù)和變量參數(shù)），因此可以在閉包函數(shù)體內(nèi)對其進行修改。閉包表達式制定了返回類型為String，以表明存儲映射值的新數(shù)組類型為String。

閉包表達式在每次被調(diào)用的時候創(chuàng)建了一個字符串并返回。其使用求余運算符 (number % 10) 計算最后一位數(shù)字并利用digitNames字典獲取所映射的字符串。

注意：字典digitNames下標后跟著一個嘆號 (!)，因為字典下標返回一個可選值 (optional value)，表明即使該 key 不存在也不會查找失敗。在上例中，它保證了number % 10可以總是作為一個digitNames字典的有效下標 key。因此嘆號可以用于強制解析 (force-unwrap) 存儲在可選下標項中的String類型值。

從digitNames字典中獲取的字符串被添加到輸出的前部，逆序建立了一個字符串版本的數(shù)字。（在表達式number % 10中，如果number為16，則返回6，58返回8，510返回0）。

number變量之后除以10。因為其是整數(shù)，在計算過程中未除盡部分被忽略。因此 16變成了1，58變成了5，510變成了51。

整個過程重復(fù)進行，直到number /= 10為0，這時閉包會將字符串輸出，而map函數(shù)則會將字符串添加到所映射的數(shù)組中。

上例中尾隨閉包語法在函數(shù)后整潔封裝了具體的閉包功能，而不再需要將整個閉包包裹在map函數(shù)的括號內(nèi)。

捕獲值（Capturing Values）

閉包可以在其定義的上下文中捕獲常量或變量。即使定義這些常量和變量的原域已經(jīng)不存在，閉包仍然可以在閉包函數(shù)體內(nèi)引用和修改這些值。

Swift最簡單的閉包形式是嵌套函數(shù)，也就是定義在其他函數(shù)的函數(shù)體內(nèi)的函數(shù)。嵌套函數(shù)可以捕獲其外部函數(shù)所有的參數(shù)以及定義的常量和變量。

下例為一個叫做makeIncrementor的函數(shù)，其包含了一個叫做incrementor嵌套函數(shù)。嵌套函數(shù)incrementor從上下文中捕獲了兩個值，runningTotal和amount。之后makeIncrementor將incrementor作為閉包返回。每次調(diào)用incrementor時，其會以amount作為增量增加runningTotal的值。

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

makeIncrementor返回類型為() -> Int。這意味著其返回的是一個函數(shù)，而不是一個簡單類型值。該函數(shù)在每次調(diào)用時不接受參數(shù)只返回一個Int類型的值。關(guān)于函數(shù)返回其他函數(shù)的內(nèi)容，請查看函數(shù)類型作為返回類型。

makeIncrementor函數(shù)定義了一個整型變量runningTotal(初始為0) 用來存儲當前跑步總數(shù)。該值通過incrementor返回。

makeIncrementor有一個Int類型的參數(shù)，其外部命名為forIncrement， 內(nèi)部命名為amount，表示每次incrementor被調(diào)用時runningTotal將要增加的量。

incrementor函數(shù)用來執(zhí)行實際的增加操作。該函數(shù)簡單地使runningTotal增加amount，并將其返回。

如果我們單獨看這個函數(shù)，會發(fā)現(xiàn)看上去不同尋常：

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

incrementor函數(shù)并沒有獲取任何參數(shù)，但是在函數(shù)體內(nèi)訪問了runningTotal和amount變量。這是因為其通過捕獲在包含它的函數(shù)體內(nèi)已經(jīng)存在的runningTotal和amount變量而實現(xiàn)。

由于沒有修改amount變量，incrementor實際上捕獲并存儲了該變量的一個副本，而該副本隨著incrementor一同被存儲。

然而，因為每次調(diào)用該函數(shù)的時候都會修改runningTotal的值，incrementor捕獲了當前runningTotal變量的引用，而不是僅僅復(fù)制該變量的初始值。捕獲一個引用保證了當makeIncrementor結(jié)束時候并不會消失，也保證了當下一次執(zhí)行incrementor函數(shù)時，runningTotal可以繼續(xù)增加。

注意：Swift 會決定捕獲引用還是拷貝值。您不需要標注amount或者runningTotal來聲明在嵌入的incrementor函數(shù)中的使用方式。Swift 同時也處理runingTotal變量的內(nèi)存管理操作，如果不再被incrementor函數(shù)使用，則會被清除。

下面代碼為一個使用makeIncrementor的例子：

    let incrementByTen = makeIncrementor(forIncrement: 10)

該例子定義了一個叫做incrementByTen的常量，該常量指向一個每次調(diào)用會加10的incrementor函數(shù)。調(diào)用這個函數(shù)多次可以得到以下結(jié)果：

    incrementByTen()
    // 返回的值為10
    incrementByTen()
    // 返回的值為20
    incrementByTen()
    // 返回的值為30

如果您創(chuàng)建了另一個incrementor，其會有一個屬于自己的獨立的runningTotal變量的引用。下面的例子中，incrementBySevne捕獲了一個新的runningTotal變量，該變量和incrementByTen中捕獲的變量沒有任何聯(lián)系：

    let incrementBySeven = makeIncrementor(forIncrement: 7)
    incrementBySeven()
    // 返回的值為7
    incrementByTen()
    // 返回的值為40

注意：如果您將閉包賦值給一個類實例的屬性，并且該閉包通過指向該實例或其成員來捕獲了該實例，您將創(chuàng)建一個在閉包和實例間的強引用環(huán)。Swift 使用捕獲列表來打破這種強引用環(huán)。更多信息，請參考 閉包引起的循環(huán)強引用。

閉包是引用類型（Closures Are Reference Types）

上面的例子中，incrementBySeven和incrementByTen是常量，但是這些常量指向的閉包仍然可以增加其捕獲的變量值。這是因為函數(shù)和閉包都是引用類型。

無論您將函數(shù)/閉包賦值給一個常量還是變量，您實際上都是將常量/變量的值設(shè)置為對應(yīng)函數(shù)/閉包的引用。上面的例子中，incrementByTen指向閉包的引用是一個常量，而并非閉包內(nèi)容本身。

這也意味著如果您將閉包賦值給了兩個不同的常量/變量，兩個值都會指向同一個閉包：

    let alsoIncrementByTen = incrementByTen
    alsoIncrementByTen()
    // 返回的值為50