- 闭包是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。
- 在Swift中的闭包与OC中的block类似。
//闭包的表达式语法
/*
{(parameters) ->(return type) in
statements
}
*/
//对整数进行排序 sorted 后面就是闭包
let numbers = [1, 5, 9, 6, 2, 3, 4]
let newNumbers = numbers.sorted { (a, b) -> Bool in
return a > b
}
print(newNumbers) //结果是 [9, 6, 5, 4, 3, 2, 1]
- 全局函数和嵌套函数其实就是特殊的闭包。
//设置全局方法获取某些值
func kNaviBarHeight() -> Float {
return 44
}
print(kNaviBarHeight())
- 闭包的形式有：
- （1）全局函数都是闭包，有名字但不能捕获任何值。
- （2）嵌套函数都是闭包，且有名字，也能捕获封闭函数内的值。
- （3）闭包表达式都是无名闭包，使用轻量级语法，可以根据上下文环境捕获值。
- Swift中的闭包有很多优化的地方:
- (1)根据上下文推断参数和返回值类型
- (2)从单行表达式闭包中隐式返回（也就是闭包体只有一行代码，可以省略return）
- (3)可以使用简化参数名，如$0, $1(从0开始，表示第i个参数...)
- (4)提供了尾随闭包语法(Trailing closure syntax)
*/
// 以下闭包以Array的sorted函数为例
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func backward(_ str1: String, _ str2: String) -> Bool {
return str1 > str2
}
// sorted函数的参数是一个闭包，下面传了一个方法名，由此说明：嵌套函数是一个有名字但并可以捕获其封闭函数域内值的闭包
var reversedNames = names.sorted(by: backward)
// 普通闭包格式：(参数: 参数类型,...) -> 返回值类型 in ...
reversedNames = names.sorted(by: { (str1: String, str2: String) -> Bool in
return str1 > str2
})
// 根据Swift的类型推断，参数类型及参数括号可以去掉，返回值类型可以去掉
reversedNames = names.sorted(by: { str1, str2 in
return str1 > str2
})
// 单行表达式：可以去掉return
reversedNames = names.sorted(by: {str1, str2 in
str1 > str2
})
// 使用参数名缩写：参数和in也可以去掉
reversedNames = names.sorted(by: {
$0 > $1 //$0代表第1个参数， $1 代表第二个参数
})
// 使用运算符：因为Swift中为字符串重载了大于号小于号
reversedNames = names.sorted(by: >)
// 使用尾随闭包：前提是闭包必须是函数的最后一个参数
reversedNames = names.sorted() {$0 < $1}
// 使用尾随闭包：闭包是函数唯一参数时，可以省掉参数括号
reversedNames = names.sorted {$0 < $1}
print(reversedNames)
- 闭包值捕获，闭包是引用类型
//sum 返回值是一个闭包 () -> Int
func sum(amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
print("runningTotal = \(runningTotal)")
runningTotal += amount
return runningTotal
}
return incrementer
}
let addByTen = sum(amount: 10)
print("结果 \(addByTen())")
print("结果 \(addByTen())")
//打印结果
/*
runningTotal = 0
结果 10
runningTotal = 10
结果 20
*/
//两次调用incrementer闭包是同一个 runningTotal 被保留下来，所以闭包是引用类型的
- 逃逸闭包和非逃逸闭包
如果这个闭包是在这个函数结束前内被调用，就是非逃逸的即noescape。
如果这个闭包是在函数执行完后才被调用，调用的地方超过了这函数的范围，所以叫逃逸闭包。
例如：snapkit的添加约束的方法就是非逃逸的。因为这闭包马上就执行了
public func makeConstraints(_ closure: (_ make: ConstraintMaker) -> Void) {
ConstraintMaker.makeConstraints(item: self.view, closure: closure)
}
网络请求请求结束后的回调的闭包则是逃逸的，因为发起请求后过了一段时间后这个闭包才执行。比如这个Alamofire里的处理返回json的completionHandler闭包，就是逃逸的。
public func response(queue: DispatchQueue? = nil, completionHandler: @escaping (DefaultDataResponse) -> Void) -> Self {
delegate.queue.addOperation {
(queue ?? DispatchQueue.main).async {
var dataResponse = DefaultDataResponse(
request: self.request,
response: self.response,
data: self.delegate.data,
error: self.delegate.error,
timeline: self.timeline
)
dataResponse.add(self.delegate.metrics)
completionHandler(dataResponse)
}
}
return self
}
举个例子，写一个模拟一个网络请求，1秒才执行，所以是逃逸闭包。
//此处编译不通过
func loadRequest(callBack: () -> Void) -> Void {
DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 1) {
callBack()
}
}
//下面是正确的写法
func loadRequest(callBack: @escaping () -> Void) -> Void {
DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 1) {
callBack()
}
}
这样就需要显示的声明@escaping才能编译通过。
AD743289-18E8-43BC-8131-9B0C5D4A50C6.png
