在上一篇文章Swift中的变量和常量中我总结了一些自己对于变量和常量的认识，最近学习了闭包，顺便给大家分享一下关于闭包的心得。本文主要是介绍Swift中闭包的简单使用，将从“闭包的定义”、"闭包的创建、赋值、调用"、“闭包常见的几种使用场景”，"使用闭包可能引起的循环强引用" 四个方面入手，重点介绍闭包如何使用，没有高深的概念，只是专注于实际使用，属于入门级水平，后面可能会有关于闭包更加详细和深入理解的文章。希望大家在阅读完本文后能够对闭包有一个整体的理解以及能够简单的使用它。

闭包的定义

在Swift开发文档中是这样介绍闭包的：闭包是可以在你的代码中被传递和引用的功能性独立模块。Swift 中的闭包和 C 以及 Objective-C 中的 block 很像，还有其他语言中的匿名函数也类似。闭包的作用主要是：能够捕获和存储定义在其上下文中的任何常量和变量的引用， 能够为你处理所有关于捕获的内存管理的操作(概念性问题，可以不用纠结太多啦)。

闭包的表达式语法
闭包表达式语法有如下的一般形式：

  { (parameters/接收的参数) -> (return type/闭包返回值类型) in
        statements/保存在闭包中需要执行的代码
  }

闭包根据你的需求是有类型的，闭包的类型 一般形式如下:

(parameters/接收的参数) -> (return type/闭包返回值类型)

利用typealias为闭包类型定义别名
这里先介绍一下 typealias的使用 : typealias是Swift中用来为已经存在的类型重新定义名字的关键字（类似于OC语法中的 typedef），重新命名的新名字用来替代之前的类型，并且能够使代码变得更加清晰简单容易理解。typealias 的用法很简单，直接用 = 赋值就可以了：

typealias <type name> = <type expression>

这里我们可以用 typealias 来为看似较为复杂的闭包类型定义别名，这样以后我们就可以用别名直接去申明这样类型的闭包了，例子如下：

 //为没有参数也没有返回值的闭包类型起一个别名
   typealias Nothing = () -> ()
    
 //如果闭包的没有返回值，那么我们还可以这样写，
   typealias Anything = () -> Void
    
 //为接受一个Int类型的参数不返回任何值的闭包类型 定义一个别名：PrintNumber
   typealias PrintNumber = (Int) -> ()
    
 //为接受两个Int类型的参数并且返回一个Int类型的值的闭包类型 定义一个别名：Add
   typealias Add = (Int, Int) -> (Int)

闭包是否接受参数、接受几个参数、返回什么类型的值完全取决于你的需求。

闭包的创建、赋值、调用

闭包表达式语法能够使用常量形式参数、变量形式参数和输入输出形式参数，但不能提供默认值。可变形式参数也能使用，但需要在形式参数列表的最后面使用。元组也可被用来作为形式参数和返回类型。在闭包的中会用到一个关键字in，in 可以看做是一个分割符，他把该闭包的类型和闭包的函数体分开，in前面是该闭包的类型，in后面是具体闭包调用时保存的需要执行的代码。表示该闭包的形式参数类型和返回类型定义已经完成，并且闭包的函数体即将开始执行。这里总结了一下可能用到的几种形式实现闭包的创建、赋值、调用的过程。例子如下:
** 方式一：利用typealias最完整的创建**

//为(_ num1: Int, _ num2: Int) -> (Int) 类型的闭包定义别名：Add
    typealias Add = (_ num1: Int, _ num2: Int) -> (Int)
//创建一个 Add 类型的闭包常量：addCloser1
    let addCloser1: Add
//为已经创建好的常量 addCloser1 赋值
    addCloser1 = {
        (_ num1: Int, _ num2: Int) -> (Int) in
        return num1 + num2
    }
//调用闭包并接受返回值
    let result = addCloser1(20, 10)

形式二：闭包类型申明和变量的创建合并在一起

//创建一个 (_ num1: Int, _ num2: Int) -> (Int) 类型的闭包常量：addCloser1
    let addCloser1: (_ num1: Int, _ num2: Int) -> (Int)
//为已经创建好的常量 addCloser1 赋值
    addCloser1 = {
         (_ num1: Int, _ num2: Int) -> (Int) in
         return num1 + num2
    }
 //调用闭包并接受返回值
    let result = addCloser1(20, 10)

形式三：省略闭包接收的形参、省略闭包体中返回值

//创建一个 (Int, Int) -> (Int) 类型的闭包常量：addCloser1
    let addCloser1: (Int, Int) -> (Int)
//为已经创建好的常量 addCloser1 赋值
    addCloser1 = {
         (num1, num2) in
         return num1 + num2
    }
//调用闭包并接受返回值
    let result = addCloser1(20, 10)

形式四：在形式三的基础上进一步精简

//创建一个 (Int, Int) -> (Int) 类型的闭包常量：addCloser1 并赋值
    let addCloser1: (Int, Int) -> (Int) = {
           (num1, num2) in
           return num1 + num2
        }    
//调用闭包并接受返回值
    let result = addCloser1(20, 10)

形式五：如果闭包没有接收参数省略in

 //创建一个 () -> (String) 类型的闭包常量：addCloser1 并赋值
     let addCloser1: () -> (String) = {
            return "这个闭包没有参数，但是有返回值"
         }
 //调用闭包并接受返回值
     let result = addCloser1()

形式六：简写的实际参数名

 //创建一个 (String, String) -> (String) 类型的闭包常量：addCloser1 并赋值
     let addCloser1: (String, String) -> (String) = {
            return "闭包的返回值是:\($0),\($1)"
         }
 //调用闭包并接受返回值
      let result = addCloser1("Hello", "Swift!")

说明： 得益于Swift的类型推断机制，我们在使用闭包的时候可以省略很多东西，而且Swift自动对行内闭包提供简写实际参数名，你也可以通过 $0, $1, $2 这样的语法来引用闭包的实际参数值。如果你在闭包表达式中使用这些简写实际参数名，那么你可以在闭包的实际参数列表中忽略对其的定义，并且简写实际参数名的数字和类型将会从期望的函数类型中推断出来。in关键字也能被省略，$0 和 $1 分别是闭包的第一个和第二个 String类型的 实际参数（引自文档翻译）。

闭包常见的几种使用场景

基本掌握闭包的概念后，我们就可以利用闭包做事情了，下面介绍一下闭包在开发中的可能被用到的场景。
场景一：利用闭包传值
开发过程中常常会有这样的需求：一个页面的得到的数据需要传递给前一个页面使用。这时候使用闭包可以很简单的实现两个页面之间传值。

图片发自简书App

实现代码:
首先在第二个界面的控制器中定义一个( String) -> ()可选类型的闭包常量closer作为SecondViewController的属性。closer接收一个String类型的参数（就是输入的文字）并且没有返回值。然后在返回按钮的点击事件中传递参数执行闭包。

import UIKit
class SecondViewController: UIViewController {
    //输入文本框
    @IBOutlet weak var textField: UITextField!
    //为创建一个(String) -> () 的可选类型的闭包变量作为控制器的属性
    var closer: ((String) -> ())?
    //返回按钮的点击事件
    @IBAction func backButtonDidClick(_ sender: AnyObject) {
        //首先判断closer闭包是否已经被赋值，如果已经有值，直接调用该闭包，并将输入的文字传进去。
        if closer != nil {
            closer!(textField.text!)
        }
        navigationController?.popViewController(animated: true)
    }
}

这里有一个注意点：我们在为SecondViewController定义变量闭包属性的时候需要将类型申明为可选类型，闭包可选类型应该是((String) -> ())?而不是(String) -> ()?的，后者指的是闭包的返回值是可选类型。
回到第一个界面的控制器中，我们需要拖线拿到UILabel的控件，然后重写prepare(for segue: UIStoryboardSegue, sender: Any?) { }方法，在这个跳转方法中拿到跳转的目标控制器SecondVC并为他的闭包属性赋值，当然如果你的跳转按钮的点击事件是自己处理的，直接在按钮的点击事件中这样做就OK了。

import UIKit
class FirstViewController: UIViewController {
    //显示文字的label
    @IBOutlet weak var label: UILabel!
    //重写这个方法
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        //拿到跳转的目标控制器
        let secondVC = segue.destination as! SecondViewController
        //为目标控制器的闭包属性赋值
        secondVC.closer = {
            //将闭包的参数(输入的文本内容)显示在label上
            self.label.text = $0
        }
    }
}

经过上面的处理，我们就可以实现两个页面之间的传值了（是不是很简单呢），当然在具体的开发中很可能不是传递文本内容这么简单，当需要传递更复杂的值时，我们可以将传递的值包装成一个模型，直接用闭包传递模型就好了。

场景二：闭包作为函数的参数
在OC语法中block可以作为函数的参数进行传递，在Swift中同样可以用闭包作为函数的参数，还记得上面利用typealias关键字定义别名吗，定义完的别名就是一个闭包类型，可以用它申明一个闭包常量或变量当做参数进行传递。一个最简单的闭包作为函数参数例子如下：

 //为接受一个Int类型的参数并且返回一个Int类型的值的闭包类型定义一个别名：Number
    typealias Number = (num1: Int) -> (Int)
 //定义一个接收Number类型的参数没有返回值的方法
    func Text(num: Number) {
      //code
    }

闭包在作为函数的参数进行传递的时候根据函数接收参数的情况有很多种不同的写法。这里我们主要介绍一下尾随闭包的概念。
首先看一下一般形式的闭包作为函数的参数传递：

//拼接两个字符串和一个整数
   func combine(handle:(String, String) -> (Void), num: Int) {
            handle("hello", "world \(num)")
        }
//方法调用
    combine(handle: { (text, text1) -> (Void) in
            print("\(text) \(text1)")
            }, num: 2016)

可以看到上面的combine方法在主动调用的时候依旧是按照func(形参: 实参)这样的格式。当我们把闭包作为函数的最后一个参数的时候就引出了尾随闭包的概念。
一，尾随闭包
尾随闭包是指当需要将一个很长的闭包表达式作为函数最后一个实际参数传递给函数时，一个书写在函数形式参数的括号外面（后面）的闭包表达式：

   func combine1(num:Int, handle:(String, String)->(Void)) {
          handle("hello", "world \(num)")
    }
   combine1(num: 2016) { (text, text1) -> (Void) in
          print("\(text) \(text1)")
    }

进一步：如果闭包表达式被用作函数唯一的实际参数并且你把闭包表达式用作尾随闭包，那么调用这个函数的时候函数名字的（）都可以省略：

   func combine2(handle:(String, String)->(Void)) {
         handle("hello", "world")
   }
   combine2 { (text, text1) -> (Void) in
         print("\(text) \(text1)")
   }

二，逃逸闭包
如果一个闭包被作为一个参数传递给一个函数，并且在函数return之后才被唤起执行，那么我们称这个闭包的参数是“逃出”这个函数体外，这个闭包就是逃逸闭包。此时可以在形式参数前写 @escaping来明确闭包是允许逃逸的。
闭包可以逃逸的一种方法是被储存在定义于函数外的变量里。比如说，很多函数接收闭包实际参数来作为启动异步任务的回调。函数在启动任务后返回，但是闭包要直到任务完成——闭包需要逃逸，以便于稍后调用。用我们最常用的网络请求举例来说：

func request(methodType:RequestMethodType, urlString: String, parameters: [String : AnyObject], completed: @escaping (AnyObject?, NSError?) -> ()) {
        // 1.封装成功的回调
        let successCallBack = { (task : URLSessionDataTask?, result : Any?) -> Void in
            completed(result as AnyObject?, nil)
        }
        // 2.封装失败的回调
        let failureCallBack = { (task : URLSessionDataTask?, error : Error?) -> Void in
            completed(nil, error as NSError?)
        }
        //判断是哪种请求方式
        if methodType == .get {
            get(urlString, parameters: parameters, success: successCallBack, failure: failureCallBack)
        } else {
            post(urlString, parameters: parameters, success: successCallBack, failure: failureCallBack)
        }
    }

这里的completed闭包被作为一个参数传递给request函数，并且在函数调用get或post后才会被调用。

使用闭包可能引起的循环强引用

Swift中不当的使用闭包可能会引起循环强引用，之所以称之为“强”引用，是因为它会将实例保持住，只要强引用还在，实例是不允许被销毁的。循环强引用会一直阻止类实例的释放，这就在你的应用程序中造成了内存泄漏。
举个例子：

import UIKit
class ThirdViewController: UIViewController {
    var callBack: ((String) -> ())?
    override func viewDidLoad() {
        super.viewDidLoad()
        printString { (text) in
            print(text)
            //闭包中捕获了self
            self.view.backgroundColor = UIColor.red
        }
    }
    func printString(callBack:@escaping (String) -> ()) {
        callBack("这个闭包返回一段文字")
        //控制器强引用于着callBack
        self.callBack = callBack
    }
    deinit {
        print("ThirdViewController---释放了")
    }
}

使用闭包何时会出现循环强引用 ：
当你把一个闭包分配给类实例属性的时候，并且这个闭包中又捕获了这个实例。捕获可能发生于这个闭包函数体中访问了实例的某个属性，比如 self.someProperty ，或者这个闭包调用了一个实例的方法，例如 self.someMethod() 。这两种情况都导致了闭包捕获了self ，从而产生了循环强引用。

闭包循环引用的本质是：
闭包中循环强引用的产生，是因为闭包和类相似（还有一种两个类实例之间的循环强引用），都是引用类型。当你把闭包赋值给了一个属性，你实际上是把一个引用赋值给了这个闭包。两个强引用让彼此一直有效。

如何解决闭包的循环强引用：

• 方式一：类似于Objective-C中使用__weak解决block的循环引用，Swift中支持使用weak关键字将类实例声明为弱引用类型（注意，弱引用类型总是可选类型），打破类实例对闭包的强引用，当对象销毁之后会自动置为nil，对nil进行任何操作不会有反应。

import UIKit
class ThirdViewController: UIViewController {
    var callBack: ((String) -> ())?
    override func viewDidLoad() {
        super.viewDidLoad()
        //将self申明为弱引用类型，打破循环引用
        weak var weakSelf = self
        printString { (text) in
            print(text)
            //闭包中铺捕获了self
            weakSelf?.view.backgroundColor = UIColor.red
        }
    }
    func printString(callBack:@escaping (String) -> ()) {
        callBack("这个闭包返回一段文字")
        //控制器强引用于着callBack
        self.callBack = callBack
    }
    deinit {
        print("ThirdViewController---释放了")
    }
}

• 方式二：作为第一种方式的简化操作，我们可以在闭包的第一个大括号后面紧接着插入这段代码[weak self]，后面的代码直接使用self？也能解决循环引用的问题。

import UIKit
class ThirdViewController: UIViewController {
    var callBack: ((String) -> ())?
    override func viewDidLoad() {
        super.viewDidLoad()
        printString {[weak self]  (text) in
            print(text)
            self?.view.backgroundColor = UIColor.red
        }
    }
    func printString(callBack:@escaping (String) -> ()) {
        callBack("这个闭包返回一段文字")
        //控制器强引用于着callBack
        self.callBack = callBack
    }
    deinit {
        print("ThirdViewController---释放了")
    }
}

• 方式三：在闭包和捕获的实例总是互相引用并且总是同时释放时，可以将闭包内的捕获定义为无主引用unowned。

import UIKit
class ThirdViewController: UIViewController {
    var callBack: ((String) -> ())?
    override func viewDidLoad() {
        super.viewDidLoad()
        printString {[unowned self]  (text) in
            print(text)
            self?.view.backgroundColor = UIColor.red
        }
    }
    func printString(callBack:@escaping (String) -> ()) {
        callBack("这个闭包返回一段文字")
        //控制器强引用于着callBack
        self.callBack = callBack
    }
    deinit {
        print("ThirdViewController---释放了")
    }
}

注意：unowned是Swift中另外一种解决循环引用的申明无主引用类型的关键字，类似于Objective-C中的__unsafe_unretained；大家都知道__weak和__unsafe_unretained的相同点是可以将该关键字修饰的对象变成弱引用解决可能存在的循环引用。不同点在于前者修饰的对象如果发现被销毁，那么指向该对象的指针会立即指向nil，而__unsafe_unretained修饰的对象如果发现被销毁，指向该对象的指针依然指向原来的内存地址，如果此时继续访问该对象很容易产生坏内存访问/野指针/僵尸对象访问。

说明：同样的道理Swift中也是一样的。和弱引用类似，无主引用不会牢牢保持住引用的实例。但是不像弱引用，总之，无主引用假定是永远有值的。因此，无主引用总是被定义为非可选类型。你可以在声明属性或者变量时，在前面加上关键字unowned 表示这是一个无主引用。由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以直接访问。不过** ARC** 无法在实例被释放后将无主引用设为 nil ，因为非可选类型的变量不允许被赋值为 nil 。如果此时继续访问已经被释放实例很容易产生坏内存访问/野指针/僵尸对象访问。所以Swift建议我们如果被捕获的引用永远不为 nil ，应该用unowned而不是weak，相反，如果你不确定闭包中捕获的引用是不是存在为nil的可能，你应该使用weak。

文章最后

以上全部内容就是本人关于闭包的心得，示例代码在Swift3.0语法下都能编译通过。如果文中有任何纰漏或错误欢迎在评论区留言指出，本人将在第一时间修改过来；喜欢我的文章，可以关注我以此促进交流学习； 如果觉得此文戳中了你的G点请随手点赞；转载请注明出处，谢谢支持。

下一篇：Swift中enum、struct、class三者异同