闭包

闭包

闭包是可以在你的代码中被传递和引用的功能性独立模块。与OC的 Block 非常相似。

表达式语法

  { (parameters) -> (return type) in
    statements
  }
  
  // 
  var add: (Int, Int) -> (Int) = {
    
    (a, b) -> (Int) in
    
    return a + b
}

add(1, 2)

如果闭包的参数是没有的，可以省略in和in前面的内容。

参数闭包

闭包作为函数的参数。当闭包放最后就是尾随闭包

func test(a: Int, b: Int, add: (Int, Int) -> (Int)) {
    
    let result = add(a, b)
    print(result)
}


test(a: 2, b: 2) { (c, d) -> (Int) in
    return c + d
}

函数需要接受闭包类型，尽量把闭包类型参数放最后

逃逸闭包

如果一个函数的参数是闭包类型，默认情况下是一个非逃逸闭包（闭包的生命周期是函数）。
使用 @escaping 代表这个闭包是逃逸闭包，有可能会被其他闭包延长生命周期（强引用）

func test(add: @escaping (Int, Int) -> (Int)) {
    
    let queue = DispatchQueue(label: "xxx")
    
    let time = DispatchTime.now() + DispatchTimeInterval.seconds(2)
    
    queue.asyncAfter(deadline: time) {
        
        add(1, 3)
    }
}

闭包的循环引用

• 使用 weak 修饰。

  class Person {
  
      var resultBlock: (() -> ())?
  
      func test() {
  
          weak var weakSelf = self
  
          resultBlock = {
  
              print("xxxx", weakSelf ?? Person())
          }
  
          resultBlock?()
      }
  
      deinit {
          print("人被释放了")
      }
  }
  
  var p: Person? = Person()
  
  p?.test()
  
  p = nil
  

• 使用[weak self]

  func test() {
  
      resultBlock = {
  
          [weak self]
  
          in
  
          print("xxxx", self)
      }
  
      resultBlock?()
  }
  

• unowned 修饰 unowned == _unsafe_unretained

  func test() {
  
      unowned let weakSelf = self
  
      resultBlock = {
          print("xxxx", weakSelf)
      }
  
      resultBlock?()
  }
  

  • unowned 修饰 unowned == _unsafe_unretained

  func test() {
  
      [unowned self] in
  
      resultBlock = {
          print("xxxx", self)
      }
  
      resultBlock?()
  }