闭包
闭包在百度百科上的定义：闭包就是能够读取其他函数内部变量的函数。
在swift中满足下面三种中的一种即为闭包。
- 有名称，但没有使用其他外部变量的全局函数。
- 有名称，能使用所在函数的变量的内嵌函数。
- 使用了可以从上下文中获取值的未命名的闭包表达式的轻量级语法。
闭包表达式
排序方法
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"]
闭包表达式语法
{ (parameters) -> return type in
statements
}
应用到排序方法中
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 } )
从上下文中推断类型
从names.sorted方法的参数类型(String,String)->Bool 可以推断出需要实现的方法的第一个参数类型是String，第二个类型是String，返回值类型是Bool
因此，闭包表达式可简写为：
reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
单行闭包表达是可以隐藏“return”关键字
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
快捷参数名
swift为内联闭包自动提供了参数的快捷参数名，按参数顺序对应的名称是$0,$1,$2,......。
reversedNames = names.sorted(by: { $0 > $1 } )
算符方法
String类型实现了特定的“大于等于”算法方法">" ，它的类型是 (String,String)->Bool，与names.sorted(by: )方法需要的参数类型匹配，swift会自动推断出使用String类型的">"方法
reversedNames = names.sorted(by: >)
Trailing Closures （尾部闭包）
如果要用闭包表达式把闭包作为方法的参数传人一个方法，就可以使用尾部闭包。
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
}
- 尾部闭包写在括号的后面。
那么前面对数组的排序可以简写为：
reversedNames = names.sorted() { $0 > $1 }
由于排序方法没有其他参数数，因此可以去掉括号，进一步简写为：
reversedNames = names.sorted { $0 > $1 }”
Capturing Values （捕获值）
闭包可以从上下文中获取常量或变量的值，
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
内嵌方法incrementer 可以从上下文中捕获参数amount和局部变量runningTotal。
let incrementByTen = makeIncrementer(forIncrement: 10)
incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30”
再创建一个Incrementer，方法makeIncrementer的局部变量runningTotal也会存储一份，不会相互影响
let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7
incrementByTen()
// returns a value of 40
闭包是引用类型
在赋值是传递的是地址
let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// returns a value of 50
Escaping 闭包
Escaping闭包需要对参数加上标签@escaping
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
Escaping闭包和非Escaping闭包的比较：
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”
Escaping闭包可以在它所在的方法体外部使用
Autoclosures
Autoclosures是一个自动创建封装表达式的闭包，这个闭包作为方法的参数。
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"
- Autoclosures的类型是无参方法。customerProvider的类型为()->String
- Autoclosures延时执行。customerProvider定义时不执行封装的表达式，调用的时候才执行。
@autoclosure
Autoclosures作为方法的参数
// 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!"
使用@autoclosure可以自动的把表达式转换为闭包，但是不方便阅读。
// 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!"