閉包和閉包表達式

1. 閉包是可以在你的代碼中杯傳遞和引用的功能性獨立代碼塊
2. 閉包能夠捕獲和儲存定義再起上下文中任何常量和變量的引用，這也就是所謂的閉合并包裹哪些常量和變量，因此被稱為“閉包”，Swift 能夠為你處理所有關(guān)于捕獲的內(nèi)存管理的操作

• 閉包的概念
• 在函數(shù)中的全局和內(nèi)嵌函數(shù)，實際上是特殊的閉包，閉包符合如下三種行駛中的一種：

1. 全局函數(shù)是一個有名字，但不會捕獲任何值的閉包
2. 內(nèi)嵌函數(shù)時一個有名字，且能從其上層函數(shù)捕獲值的閉包
3. 閉包表達式是一個輕量級語法所寫的，可以捕獲其上下文中常量或變量值的沒有名字的閉包

• 閉包表達式

1. 閉包表達式是一種在簡短行內(nèi)就能寫完的閉包的語法

• 閉包表達式-從sorted 函數(shù)說起
• Swift 的標準庫提供了一種叫做 sorted(by:) 的方法，會根據(jù)你提供的排序閉包將已知類型的數(shù)組的值進行排序，一旦它排序完成， sorted(by:) 方法會返回與原數(shù)組類型大小完全相同的一個新數(shù)組，該數(shù)組的元素是已排序好的，原始數(shù)組不會被sorted(by:) 方法修改

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward(_:_:))
print(reversedNames)

• 閉包表達式語法
• 閉包表達式語法能夠使用常量形式參數(shù)、變量形式參數(shù)和輸入輸出形式參數(shù)，但不能提供默認值?？勺冃问絽?shù)也能使用，但需要在形式參數(shù)列表的最后面使用。元組也可被用來作為形式參數(shù)和返回類型

{ (parameters) -> (return type) in
    statements
}

• 閉包表達式語法版本的 backward

1. 將之前 backward(::) 函數(shù)改為閉包表達版本

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted { (s1: String, s2: String) -> Bool in
    return s1 > s2
}
print(reversedNames)

• 從語境中推斷類型

1. 因排序閉包為實際參數(shù)來傳遞給函數(shù)，故Swift能推斷它的形式參數(shù)類型和返回類型
2. sorted(by:) 方法期望它的形式參數(shù)是一個 (String, String) -> Bool 類型的函數(shù)，這意味著 (String, String) 和 Bool 類型不需要被寫成閉包表達式定義中的一部分，因為所有的類型都能被推斷，返回箭頭 (->) 和圍繞在形式參數(shù)名周圍的括號也能被省略

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted(by: { s1, s2 in return s1 > s2})
print(reversedNames)

• 從單表達式閉包隱式返回

1. 單表達式閉包能夠從他們的聲明中刪除return 關(guān)鍵字，來隱式返回他們單個表達式的結(jié)果

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted(by: { s1, s2 in s1 > s2})
print(reversedNames)

• 簡寫實際參數(shù)名

1. Swift自動對行內(nèi)閉包提供簡寫實際參數(shù)，可以通過 1, $2 等名字來引用閉包的實際參數(shù)值

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted(by: { $0 > $1})
print(reversedNames)

• 運算符函數(shù)
  Swift 的 String類型定義了關(guān)于大于號（>）的特定字符串實現(xiàn)，讓其作為一個由兩個 String 類型形式參數(shù)的函數(shù)并返回一個 Bool 類型的值，這正好與sorted(by:) 方法的形式參數(shù)需要的函數(shù)相匹配，因此，你能簡單的傳遞一個大于號，并且Swift 將推斷你想使用大于號 特殊字符串函數(shù)實現(xiàn)

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted(by: >)
print(reversedNames)

• 尾隨閉包

1. 如果你需要講一個很長的閉包表達式作為函數(shù)最后一個實際參數(shù)傳遞給函數(shù)，使用尾隨閉包將增強函數(shù)的可讀性，尾隨閉包是一個被書寫在函數(shù)形式參數(shù)的括號外邊(后面)的閉包表達式

let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted{ $0 > $1}
print(reversedNames)

閉包捕獲值

• 捕獲值

1. 一個閉包能夠從上下文捕獲一杯定義的常量和變量。即使定義這些常量和變量的原作用域已經(jīng)不存在，閉包仍能夠在其函數(shù)體內(nèi)引用和修改這些值。

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

2. 作為一種優(yōu)化，如果一個值沒有改變或者在閉包的外邊，Swift可能會使用這個值的拷貝而不是捕獲
3. Swift 也處理了變量的內(nèi)存管理操作，當遍歷不再需要時被釋放

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

4.如果你建立了第二個incrementer，它將會有一個新的、獨立的runningTotal變量的引用

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

let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()

incrementByTen()

• 閉包是引用類型

1. 在 Swift 中，函數(shù)和閉包都是引用類型
2. 無論你什么時候賦值一個函數(shù)或者閉包給常量或者變量，你實際上都是講常量和變量設(shè)置為對函數(shù)和閉包的引用

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

let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()

incrementByTen()

let also = incrementByTen
also()

• 閉包是引用類型

1. 如果你分配了一個閉包給類實例的屬性，并且閉包通過引用該實例或者它的成員來捕獲實例，你將在閉包和實例間會產(chǎn)生循環(huán)引用。

逃逸閉包和自動閉包

• 逃逸閉包

1. 當閉包作為一個實際參數(shù)傳遞給一個函數(shù)的時候，并且它會在函數(shù)返回值后調(diào)用，我們就說這個閉包逃逸了。當你聲明一個接受閉包作為形式參數(shù)的函數(shù)時，你可以在形式參數(shù)前些 @escaping 來明確閉包是允許逃逸的
2. 閉包可以逃逸的一種方法是被存儲定義與函數(shù)歪的變量里，比如說，很多函數(shù)接受閉包實際參數(shù)來作為啟動異步任務(wù)的回調(diào)，函數(shù)在啟動任務(wù)后返回，但是閉包要知道任務(wù)完成--閉包需要逃逸，一遍稍后調(diào)用

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

3. 讓閉包 @escaping 意味著你必須在比閉包中顯示地引用 self

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

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithNonescapingClosure {
            self.x = 100
        }
        someFunctionWithNonescapingClosure {
            x = 200
        }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)

completionHandlers.first
print(instance.x)

• 自動閉包

1. 自動閉包是一種自動創(chuàng)建的用來把作為實際參數(shù)傳遞給函數(shù)的表達式打包的閉包，它不接受任何實際參數(shù)，并且當它被調(diào)用時，它會返回內(nèi)部打包的表達式的值
2. 這個語法的好處在于通過寫普通表達式，代替顯式閉包而使你省略保衛(wèi)函數(shù)形式參數(shù)的括號
3. 自動閉包允許你延遲處理，因此閉包內(nèi)部的代碼知道你調(diào)用它的時候才會運行，對于有副作用或者暫用資源的代碼來說很有用，因為它可以允許你控制diamante何時進行求值

var customersInLine = ["one", "two", "three", "four", "five"]
print(customersInLine.count)

let customerProvider = { customersInLine.remove(at: 0)}
print(customersInLine.count)

print("Now serving \(customerProvider())!")
print("Now serving \(customerProvider())!")
print(customersInLine.count)

4. 當你傳一個閉包作為實際參數(shù)到函數(shù)的時候，你會得到與延遲處理相同的行為

var customersInLine = ["one", "two", "three", "four", "five"]
print(customersInLine.count)

func serve(customer customerProvider: () -> String ) {
    print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) })
print(customersInLine.count)

5. 通過 @ autoclosure 標志標記它的形式參數(shù)使用了自動閉包，現(xiàn)在你可以調(diào)用函數(shù)就像它接受了一個String 實際參數(shù)而不是閉包，實際參數(shù)自動地轉(zhuǎn)換為閉包，因為 CustomerProvider形式參數(shù)的類型被標記為 @autoclosure標記

var customersInLine = ["one", "two", "three", "four", "five"]
print(customersInLine.count)
  
func serve(customer customerProvider: @autoclosure () -> String ) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
print(customersInLine.count)

• 自動+逃逸

1. 如果你想要自動閉包允許逃逸，就同時使用 @autoclosure 和 @escaping 標志

var customersInLine = ["one", "two", "three", "four", "five"]
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.")

for customerProvider in customerProviders {
    print("Now serving \(customerProvider())!")
}