Swift闭包的基础笔者已经写了一篇，如果你还不是很清楚基本使用，建议先看基础篇，如果已经会了，那直接跳过，一起学习闭包进阶篇吧
逃逸闭包与非逃逸闭包
逃逸闭包概念：当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。
非逃逸闭包概念：当一个闭包作为参数传到一个函数中，并且这个闭包在函数没有返回之前就执行完了，我们称该闭包为非逃逸闭包。
举个例子说明这个问题
class ViewController: UIViewController {
var x = 10
var callBackArray: [() -> Void] = []
// 逃逸闭包
func testEscapingClosure(callBack: @escaping () -> Void) {
callBackArray.append(callBack)
}
// 非逃逸闭包
func testNoEscapingClosure(closure: () -> Void) {
closure()
}
override func viewDidLoad() {
super.viewDidLoad()
testEscapingClosure { [unowned self] () -> Void in
self.x = 100 // 逃逸闭包需要显式的写出self
}
testNoEscapingClosure {
x = 200 // 非逃逸闭包无需显式的写出self
}
print(x) // 200
callBackArray.first?() // 修改了x
print(x) // 100
DispatchQueue.main.async {
self.x = 1 // 逃逸闭包需要显式的写出self
}
}
}
为什么逃逸闭包需要显式的写self，而非逃逸闭包可以省略不写？分析这个问题我们分两步分析：
1 非逃逸闭包为什么可以不用写self
当执行testNoEscapingClosure函数的时候，函数体中创建了一个局部变量引用着closure闭包，闭包中要访问对象self中的成员变量首先需要引用self，此时在内存中的关系如图所示，并不会出现循环引用，当函数执行结束，引用着闭包的成员变量会被释放，从而图示中的虚线断开了，闭包引用计数为0，在内存中被清除。针对这种肯定不会出现循环引用的情况，苹果可能为了简化代码，让开发者无需显式的写出self，当然你要写也是能正常编译的。
2 逃逸闭包为什么需要写self
当执行testEscapingClosure函数的时候，函数体创建了一个局部变量引用着callBack闭包，闭包中要访问self中的成员变量需要引用self，但是要注意的是这里只能弱引用[weak self]或者指向self所在内存(引用计数不增加)[unowned self]，图示用虚线体现出来了，这样就避免了循环引用，而这个操作是需要开发人员自己通过代码处理的[unowned self] [weak self]，针对这种可能会出现循环引用的情况，苹果希望开发者显式的写出self。
需要注意的是下面的代码也是逃逸闭包，为什么？我画个图能把这个问题说清楚
override func viewDidLoad() {
print("任务1")
DispatchQueue.main.async {
self.x = 1 // 逃逸闭包需要显式的写出self
}
print("任务3")
}
DispatchQueue.main.async的作用其实就是将闭包任务添加到Main队列中（往指定队列队尾追加），同时指定在执行闭包的时候是否创建新线程(这里虽然是异步，但是在主队列，所以不会创建新线程)，之后再执行任务3，任务3执行完毕，函数viewDidLoad就结束了，如图所示，闭包任务并没有在viewDidLoad中，他不仅要等viewDidLoad结束，还得等viewWillAppear....结束才能开始执行，既然如此，当然就是逃逸闭包了。
自动闭包
自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。这种闭包不接受任何参数，当它被调用的时候，会返回被包装在其中的表达式的返回值。
下面看段自动闭包的代码事例：
class ViewController: UIViewController {
let aa = { () -> String in
print("do some thing")
return "Autoclosures test"
}
func test(_ f: () -> String) {
print(f())
}
// 将传进来的 表达式 自动闭包
func testAutoclosures(_ f: @autoclosure () -> String) {
print(f())
}
override func viewDidLoad() {
super.viewDidLoad()
// 直接传闭包代码块
test { () -> String in
print("aaa");
return "hahaha"
}
// 传闭包名
test(aa)
// 表达式 aa() 将会被自动闭包
testAutoclosures(aa())
}
}
上面这段代码事例默认是非逃逸闭包，有时候可能有逃逸闭包的场景，下面举个自动闭包又是逃逸闭包的例子：（注意看代码上的注释，我这里把解释通过注释的形式体现出来了）
class ViewController: UIViewController {
var x = 10
var closureArray: [() -> String] = []
func bb() -> String {
x = 20
return String(x)
}
func testAutoclosure(_ f: @escaping () -> String) {
closureArray.append(f)
}
// 自动闭包，并且是逃逸闭包
func testAutoclosure2(_ f: @autoclosure @escaping () -> String) {
closureArray.append(f)
}
override func viewDidLoad() {
super.viewDidLoad()
// 直接通过闭包名传递，注意：这种写法会retainCycle
// testAutoclosure(bb)
// 既然上面会出现retainCycle，那么自己包装一个闭包，在闭包中解决retainCycle
testAutoclosure { [unowned self] () -> String in
self.bb()
}
// 注意：这种写法会retainCycle 这里不仔细是非常容易犯错的
// testAutoclosure2(self.bb())
// @autoclosure会自动帮我们生成闭包
unowned let assingSelf = self
testAutoclosure2(assingSelf.bb()) // 参数传 表达式 ，闭包处理苹果会自动处理
// 用weak解决循环引用
weak var weakSelf = self
testAutoclosure2( (weakSelf?.bb())! )
}
}
关于上面这个例子，有细节部分需要特别注意的，很容易忽略导致内存泄露，testAutoclosure2(xxxx) 为什么要用weak引用或者unowned？我尝试通过图来说明一下：
当我们封装完的一个函数，恰好有一个场景可以把函数转成闭包直接用的时候，这时自动闭包就起作用了，代码看起来会简短很多，不过个人建议这种代码还是少用为妙，因为他并不易读。
循环引用
关于循环引用，上面分析逃逸闭包和自动闭包的时候也有做描述，如果还不是很明白为什么会出现循环引用，可以参考一下笔者的这篇文章，IOS之block和内存那些事，虽然用的是OC举得例子，其实原理差不多的。然后我还想强调的是，不要死记会出现循环引用的场景和解决办法，应该分析内存去理解，只有理解了，代码千变万化，自要保持冷静去分析，相信都能思考出想要的答案。
闭包捕获、闭包是引用类型
闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
class ViewController: UIViewController {
func testCapture() -> () -> Int {
var count = 0
func closureFunc() -> Int {
count = count + 10
return count
}
return closureFunc
}
override func viewDidLoad() {
super.viewDidLoad()
let test1 = testCapture()
print(test1()) // 10
print(test1()) // 20
print(test1()) // 30
let test2 = test1
print(test2()) // 40
print(test2()) // 50
let test3 = testCapture()
print(test3()) // 10
print(test1()) // 60
}
}
这段代码看起来非常好理解，不过有个疑惑，看图
test1和test2内存地址一样好理解，因为是引用类型赋值，但是test3内存地址也一样，如果test3内存地址一样，那么最后一句print(test1()) 为什么不是20？
类似的疑惑
class ViewController: UIViewController {
// 逃逸闭包
var x = 10
var callBackArray: [() -> Void] = []
func testEscapingClosure(callBack: @escaping () -> Void) {
callBackArray.append(callBack)
}
override func viewDidLoad() {
super.viewDidLoad()
testEscapingClosure { [unowned self] () -> Void in
self.x = 100 // self -> 0x000060000000c821
}
testEscapingClosure { [weak self] () -> Void in
self?.x = 100 // self -> 0x7ff940408310
}
// self -> 0x7ff940408310
callBackArray[0]()
callBackArray[1]()
}
}
从注释可以看出captureList里的self，用weak修饰的self内存地址和外面的self内存地址一致，这也和预期想的一样，然而unowned里的self内存地址变了，难道不也是和外面的self地址一样，只不过是引用计数不加1？这个问题我正在研究，回头再分享。
