Swift3.x - 闭包

闭包的介绍
闭包是自包含的函数代码块、可以在代码中被传递和使用。Swift中的闭包与C和OC中的代码块（Block）比较相似！
闭包拥有三种形式：

• 全局函数是一个有名字但不会捕获任何值的闭包
• 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
• 闭包表达式是一个利用轻量级语法缩写的可以捕获其上下文中变量或常量值的匿名闭包

闭包表达式
闭包表达式一般形式：

{ (parameters) -> returnType in
    statements
}

闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。

函数中闭包的定义
在函数中使用闭包，定义方式如下：

import UIKit

class SomeTool: NSObject {
    func loadData(callBack : @escaping (String) -> ()) {
        
        DispatchQueue.global().async {
            print("开始异步加载...")
            
            DispatchQueue.main.async {
                print("主线程更新UI")
                callBack("change UI")
            }
        }
    }
}

注释：

• callBack为闭包参数名
• (String) -> ()为闭包类型
• @escaping关键字表示闭包为“逃逸闭包”
• Swift3.0中完全颠覆了原OC中得GCD写法，用法更加简洁

下面在控制器中调用上述含有闭包的函数：代码如下所示：

import UIKit

class ViewController: UIViewController {
    var tool : SomeTool = SomeTool()
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        tool.loadData { (info) in
            print("\(info)")
        }
    }
}
//结果：
//开始异步加载...
//主线程更新UI
//change UI

逃逸闭包
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。
在Swift3.0之前，闭包默认时逃逸的，Swift3.0之后默认是非逃逸的，所以在使用逃逸闭包时，需要添加关键字@escaping，并且添加位置在闭包类型名前而不是参数名前！

闭包循环引用的解决办法
闭包的循环引用的解决办法有三种方式：

• 方式一：
  类似OC中的写法，设置weakSelf方式：

  import UIKit

  class ViewController: UIViewController {
      var tool : SomeTool = SomeTool()
      override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
          //1、解决闭包循环引用的方式一：
          //1.弱引用self设置
          weak var weakSelf = self
          tool.loadData { (info) in
              //1.1 弱引用self使用
               /**weakSelf?.view：
                   如果前面的可选类型，没有值，后面所有代码都不会执行
                   若果前面的可选类型，有值，系统会自动将weakSelf进行解包，并且使用weakSelf
               */
              weakSelf?.view.backgroundColor = UIColor.blue
          
              print("\(info)")
          }
      }
  }

• 方式二：
  Swift中方式一的简便写法（推荐写法）：

    import UIKit

    class ViewController: UIViewController {
        var tool : SomeTool = SomeTool()
        override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {

            //2、解决闭包循环引用的方式二：（推荐写法）
            //2.方式一的简便写法
            tool.loadData { [weak self] (info) in
                self?.view.backgroundColor = UIColor.blue
                print("\(info)")
            }
        }
    }

• 方式三：
  方式三相当于OC中的__unsafe_unretained方式：

    import UIKit

    class ViewController: UIViewController {
        var tool : SomeTool = SomeTool()
        override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        
            //3、解决闭包循环引用的方式三：
            //3.比较危险
            //相当于OC中的__unsafe_unretained
            //__unsafe_unretained：修饰的弱引用，当指向的对象销毁，指针还会指向已经销毁的内存地址（野指针）/访问僵尸对象
            //__weak：修饰的弱引用，如果指向的对象销毁，那么指针会指向nil
            tool.loadData { [unowned self] (info) in
                self.view.backgroundColor = UIColor.blue
                print("\(info)")
            }
        }
    }

尾随闭包
如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
通俗的意思就是：函数的最后一个参数为闭包，此闭包就为尾随闭包，存在简便使用闭包的形式！
上述闭包的用法，其实质就是尾随闭包！
继续使用上述例子，来解释一下尾随闭包：

import UIKit

class ViewController: UIViewController {
    var tool : SomeTool = SomeTool()
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        
        //1、尾随闭包方式一：
        tool.loadData{ (info) in
            print("\(info)")
        }
        
        //2、尾随闭包方式二：
        tool.loadData (callBack: { (info) in
            print("\(info)")
        })
        
        //3、尾随闭包方式三：
        tool.loadData(){ (info) in
            print("\(info)")
        }
    }
}

Zeb
参考地址：https://github.com/numbbbbb/the-swift-programming-language-in-chinese