闭包
Swift的闭包类型类似于C和Objective-C中的块以及其他编程语言的Lambdas。
闭包可捕获并存储其定义的上下文中的任何常量和变量的引用，称为捕获常量和变量。
全局函数和嵌套函数实际上是闭包的特殊情况，闭包有三种形式：
- 全局函数是具有函数名且不捕获值的闭包。
- 嵌套函数是具有函数名且捕获函数体内的值的闭包。
- 闭包表达式是轻量级的未命名闭包，且从其上下文中捕获值。
Swift的闭包表达式经过优化后鼓励使用简单、整洁的语法，包括：
- 从上下文推倒参数和返回值类型
- 单个闭包表达式的隐式返回
- 参数名称简写
- 尾随闭包语法
<br />
闭包表达式
闭包表达式是一种以简短语法编写内联闭包的方法。下面的闭包表达式示例通过闭包表达式说明这些语法优化。
排序方法
sorted(by:)方法根据传入的排序闭包的输出对已知类型的数组进行排序，并返回已排序好的新数组，原数组未被修改。
sorted(by:)方法接收一个闭包，该闭包接收与数组元素相同类型的两个参数，并返回Bool值，表示前值应该在后值之前(返回true)或之后(返回false)出现。
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func backward(_ s1: String, _ s2: String) -> Bool {
return s1 > s2
}
var reversedNames = names.sorted(by: backward)
// reversedNames is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
然后，这是一个相当长的方式来编写本质上是单表达式函数(a > b)，可使用闭包表达式语法来编写排序闭包。
闭包表达式语法
闭包表达式语法有以下形式：
{ (parameters) -> return type in
statements
}
闭包表达式语法中的参数可以是in-out参数和可变参数，但不能有默认值。元组可用作参数类型和返回类型。
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
return s1 > s2
})
可将闭包表达式写在单行：
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )
从上下文推导类型
由于排序闭包作为参数传递给方法，Swift可推断其参数的类型和返回值的类型。因为可以推断所有的类型，所以返回箭头和参数名周围括号也可省略。
reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
单表达式闭包的隐式返回
单表达式闭包可省略return关键字来隐式返回单个表达式的结果：
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
参数名简写
Swift自动为内联闭包提供简写参数名称，可通过名称$0、$1、$2等引用闭包参数值。
若闭包表达式使用简写参数名称，则可以从定义中省略闭包的参数列表，并根据预期函数类型推断简写参数名称的数量和类型，in关键字也可省略，因为闭包表达式完全由其主体组成：
reversedNames = names.sorted(by: { $0 > $1 } )
这里的$0和$1表示闭包的第一个和第二个String参数。
运算符方法
还有更加简短的方式书写上述闭包表达式。Swift的操作符本质上就是函数，可以简单地传入运算符作为闭包表达式：
reversedNames = names.sorted(by: >)
<br />
尾随闭包
当需要传入一个较长的闭包表达式作为函数的最后一个参数时，那这个闭包表达式就是尾随闭包。使用尾随闭包语法时，不要将闭包的参数标签写入函数调用的一部分。
func someFunctionThatTakesAClosure(closure: () -> Void) {
// function body goes here
}
// Here's how you call this function without using a trailing closure:
someFunctionThatTakesAClosure(closure: {
// closure's body goes here
})
// Here's how you call this function with a trailing closure instead:
someFunctionThatTakesAClosure() {
// trailing closure's body goes here
}
可以将sorted(by:)方法的字符串排序闭包写成尾随闭包：
reversedNames = names.sorted() { $0 > $1 }
当闭包表达式是函数的唯一参数时，且该表达式为尾随闭包，那么在调用该函数时不需要在函数名后写一对圆括号()。
reversedNames = names.sorted { $0 > $1 }
Array类型的map(_:)方法将闭包作为唯一参数，其作用是返回一个按照闭包的映射规则映射所有元素的新数组。将该闭包表达式写成尾随闭包：
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]
let strings = numbers.map { (number) -> String in
var number = number
var output = ""
repeat {
output = digitNames[number % 10]! + output
number /= 10
} while number > 0
return output
}
// strings is inferred to be of type [String]
// its value is ["OneSix", "FiveEight", "FiveOneZero"]
<br />
捕获值
闭包能从定义的上下文捕获常量和变量，即使定义常量和变量的原始范围不再存在，闭包也可以引用病修改这些值。
在Swift中，可以捕获值的最简单的闭包形式是一个嵌套函数。嵌套函数可以捕获其外部函数的任何参数，也可以捕获外部函数中定义的任何常量和变量。
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
上述嵌套函数incrementer捕获了外部函数makeIncrementer的参数amount和外部函数定义的runningTotal变量。
将incrementer函数保存为常量或变量，函数内对runningTotal和amount的引用依然存在：
let incrementByTen = makeIncrementer(forIncrement: 10)
incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30
创建另一个incrementer函数，捕获值的引用也随之初始化：
let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7
调用原来的incrementByTen函数会继续引用自己的runningTotal变量，且不会影响到incrementBySeven函数捕获到的变量：
incrementByTen()
// returns a value of 40
<br />
闭包是引用类型
函数和闭包都是引用类型，无论何时为常量或变量分配函数或闭包，就将该常量或变量设置为对函数或闭包的引用。若将闭包分配给两个不同的常量或变量，这些常量或变量都将使用相同的闭包：
let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// returns a value of 50
<br />
逃逸闭包
非逃逸闭包的生命周期：
- 把闭包作为参数传递给函数。
- 函数中运行该闭包。
- 退出函数。
非逃逸闭包的引用计数和退出函数时保持不变。
逃逸闭包与非逃逸闭包相反，当函数退出时，逃逸闭包的引用仍然被其他对象持有，不会在持有函数结束后释放。
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
func someFunctionWithNonescapingClosure(closure: () -> Void) {
closure()
}
class SomeClass {
var x = 10
func doSomething() {
someFunctionWithEscapingClosure { self.x = 100 }
someFunctionWithNonescapingClosure { x = 200 }
}
}
let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"
completionHandlers.first?()
print(instance.x)
// Prints "100"
使用逃逸闭包的两个场景：
- 异步调用：如果需要调度队列中异步调用闭包， 这个队列会持有闭包的引用，至于什么时候调用闭包，或闭包什么时候运行结束都是不可预知的。
- 需要存储闭包作为属性，全局变量或其他类型做稍后使用。
<br />
自动闭包
自动闭包是一个自动创建的闭包，用于包装一个作为参数传递给函数的表达式。它没有任何参数，当被调用时，它返回包含在其中的表达式的值。
自动闭包让代码延迟之行，在调用闭包之前，内部代码不会运行。延迟之行对具有副作用或计算上昂贵的代码很有用，可以控制何时执行该代码：
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// Prints "5"
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// Prints "5"
print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// Prints "4"
即使customersInLine数组的第一个元素被封装内部的代码删除，数组元素在世纪调用闭包之前不会被删除。customerProvider的类型不是String，而是 () -> String ：一个返回字符串没有参数的函数。
当将闭包作为函数传递给函数时，依然会延迟执行：
// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } )
// Prints "Now serving Alex!"
// customersInLine is ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
// Prints "Now serving Ewa!"
注意
过度使用自动闭包会使代码难以理解，应通过上下文和函数名称说明正在使用延迟执行。
同时使用逃逸闭包和自动闭包：
// customersInLine is ["Barry", "Daniella"]
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.")
// Prints "Collected 2 closures."
for customerProvider in customerProviders {
print("Now serving \(customerProvider())!")
}
// Prints "Now serving Barry!"
// Prints "Now serving Daniella!"
