CategoryBottomView.swift文件里：
override init(frame: CGRect) {
super.init(frame: frame)
var outGroups = [AnyObject]()
//传入了outGroups参数
YMNetworkTool.shareNetworkTool.loadCategoryGroup { [weak self] (outGroups) in
self!.outGroups = outGroups
self!.setupUI()
}
}YMNetworkTool.swift文件里：
func loadCategoryGroup(finishe:(outGroups: [AnyObject]) -> ()) {
//执行各种操作
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。省略
outGroups.append(inGroups)
//将得到的outGroups的数据传传递进去
}
闭包的表达式语法
闭包表达式语法有如下的一般形式：
1 2 3 | |
闭包根据你的需求是有类型的，闭包的类型 一般形式如下:
(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类型的 实际参数（引自文档翻译）。
闭包常见的几种使用场景
基本掌握闭包的概念后，我们就可以利用闭包做事情了，下面介绍一下闭包在开发中的可能被用到的场景。
场景一：利用闭包传值
开发过程中常常会有这样的需求：一个页面的得到的数据需要传递给前一个页面使用。这时候使用闭包可以很简单的实现两个页面之间传值。
frameborder="0" allowtransparency="true" scrolling="no" vspace="0" hspace="0" style="display: block; position: static; padding: 0px; margin: 0px; border-style: none; vertical-align: baseline; width: 604px; height: 112px;">
图片发自简书App
场景再现：
第一个界面中有一个用来显示文字的UILabel和一个点击进入到第二个界面的UIButton,第二个界面中有一个文本框UITextField和一个点击返回到上一个界面的UIButton,现在的需求是在第二个界面的UITextField中输入完文字后，点击返回按钮返回到第一个界面并且将输入的文字显示在第一个界面（当前页面）的UILabel中。
实现代码:
首先在第二个界面的控制器中定义一个( 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---释放了" )
}
}
frameborder="0" allowtransparency="true" scrolling="no" vspace="0" hspace="0" style="display: block; position: static; padding: 0px; margin: 0px; border-style: none; vertical-align: baseline; width: 604px; height: 112px;">
当你在定义printString这个方法时执行self.callBack = callBack代码实际上是self对callBack闭包进行了强引用，到这里其实并没有产生循环引用，但是当你在调用printString方法的闭包里面又访问了self.view.backgroundColor属性，此时强引用就发生了，即self引用了callBack,而callBack内部又引用着self,谁都不愿意松手，我们就说这两者之间产生了循环强引用。
使用闭包何时会出现循环强引用 ：
当你把一个闭包分配给类实例属性的时候，并且这个闭包中又捕获了这个实例。捕获可能发生于这个闭包函数体中访问了实例的某个属性，比如 self.someProperty ，或者这个闭包调用了一个实例的方法，例如 self.someMethod() 。这两种情况都导致了闭包捕获了self ，从而产生了循环强引用。
闭包循环引用的本质是：
闭包中循环强引用的产生，是因为闭包和类相似（还有一种两个类实例之间的循环强引用），都是引用类型。当你把闭包赋值给了一个属性，你实际上是把一个引用赋值给了这个闭包。两个强引用让彼此一直有效。
如何解决闭包的循环强引用：
方式一：类似于OC中使用__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中另外一种解决循环引用的申明无主引用类型的关键字，类似于OC中的__unsafe_unretained；大家都知道__weak和__unsafe_unretained的相同点是可以将该关键字修饰的对象变成弱引用解决可能存在的循环引用。不同点在于前者修饰的对象如果发现被销毁，那么指向该对象的指针会立即指向nil，而__unsafe_unretained修饰的对象如果发现被销毁，指向该对象的指针依然指向原来的内存地址，如果此时继续访问该对象很容易产生坏内存访问/野指针/僵尸对象访问。
同样的道理Swift中也是一样的。和弱引用类似，无主引用不会牢牢保持住引用的实例。但是不像弱引用，总之，无主引用假定是永远有值的。因此，无主引用总是被定义为非可选类型。你可以在声明属性或者变量时，在前面加上关键字unowned 表示这是一个无主引用。由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以直接访问。不过 ARC 无法在实例被释放后将无主引用设为 nil ，因为非可选类型的变量不允许被赋值为 nil 。如果此时继续访问已经被释放实例很容易产生坏内存访问/野指针/僵尸对象访问。
所以Swift建议我们如果被捕获的引用永远不为 nil ，应该用unowned而不是weak，相反，如果你不确定闭包中捕获的引用是不是存在为nil的可能，你应该使用weak。
