浅谈oc与Swift中闭包的使用

▍先看oc：

初始化block时，所使用的外部变量已经被处理完毕，而不是执行block时处理。

一般情况(没有__block修饰)下，该变量被常量拷贝(const obj)到block中；存在__block修饰时，该变量被引用(& obj)到block中。

拷贝初始化oc对象指针时，分为4中情况：
strong/weak-to-strong: pointee's retain count +1
strong/weak-to-weak: pointee's retain count +0

如果该变量是指向oc对象的指针，我们一般不会对该变量使用__block修饰，这种情况下该变量被拷贝到block中，默认strong-to-strong、weak-to-weak。

举个：ARC环境，就是常见的strong-weak-dance

// 初始化TestObject类实例(oc对象)、声明并初始化指向该实例的指针obj (retain count = 1)
TestObject *obj = [TestObject new];
// 声明并初始化weak指针weakObj，执行拷贝初始化strong-to-weak (retain count +0)
__weak typeof(obj) weakObj = obj;
// 构造block同时拷贝weakObj到block中，执行拷贝初始化weak-to-weak (retain count +0)
// 为obj.block赋值
obj.block = ^{
  // 声明并初始化指针obj，执行拷贝初始化weak-to-strong (retain count +1)
  typeof(obj) obj = weakObj;

  [obj doSomething];

  // 弹栈，释放指针obj (retain count -1)
};
obj.block();

▍再看Swift:

Swift中closure使用与其他语言(C++,Python...)中lambda类似的对象捕捉，原理与oc是一样的；虽然Swift弱化指针概念，但仍旧可以用oc中的block的思路来分析，这里就不多嘴了。

class TestTest: NSObject {
  var name: String
  var block: (()->Void)?
  init(name: String) { self.name = name }
  deinit { print("\(self.name) say: i am gone") }
}
// 初始化后立刻析构，与oc相同，但是IDE没有警告
weak var a: TestTest? = TestTest(name:"a") 

strong-weak-dance仍然有效

{
  defer { print("haha: i am gone") }
  let a: TestTest = TestTest(name:"a")
  weak var weakA = a
  a.block = {
    var a = weakA
    print("2a = \(a)")
    DispatchQueue.global().asyncAfter(deadline: .now() + 2, execute: {
      print("3a = \(a)")
    })
  }
  a.block?()
  print("1a = \(a)")
}()

运行结果：

strong-weak-dance in Swift

在Swift中有更优雅的写法

{
  defer { print("haha: i am gone") }
  let a: TestTest = TestTest(name:"a")
  a.block = { 
    // 直接将外部变量(指针)a拷贝到closure内部，执行拷贝初始化strong-to-weak
    [weak a] in
    var a = a
    print("2a = \(a)")
    DispatchQueue.global().asyncAfter(deadline: .now() + 2, execute: {
      print("3a = \(a)")
    })
  }
  a.block?()
  print("1a = \(a)")
}()

运行结果：

优雅的strong-weak-dance in Swift

关于self

当closure引入外部变量名为self时，局部变量self会被IDE提示改为`self`，后续使用时，可以用`self`或者直接self。

{ 
  [weak self] in
  var `self` = self
  `self`.dance()
  self.dance()
}()

关于unowned和weak

unowned需要程序员保证closure使用捕获的unowned变量时，该变量一定不为nil，这一点在代码长期维护的情况下难以保证(存在类似需求时，我通常使用断言/异常)；而使用strong-weak-dance配合guard可以实现相同的需求且少出错。

{ [weak a] in
  // 如果closure需要a不为nil，可以使用guard
  guard let a = a else {
    // 如果a为nil是错误，可以使用断言或者异常
    assert(false, "some reason ...")
    return
  }
  // do some thing
}