Swift闭包(二)：进阶篇

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？这个问题我正在研究，回头再分享。