一、闭包的概念
Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 匿名函数比较相似。
它的本质一个函数，一个可执行的代码块，只是这个函数是没有名字的，也就是匿名函数。你也可以把他看作如 int、float一样，是一种数据类型，一种可以作为参数传递的数据类型。
二、基本语法
1、闭包的声明
//定义一个求和闭包
//闭包类型：(Int,Int)->(Int)
let add:(Int,Int)->(Int) = {
(a,b) in
return a + b;
}
//执行闭包，相当于调用函数
let result = add(1100, 200);
//打印闭包返回值
print("result=\(result)");
闭包类型是由参数返回值决定，如上述add闭包类型为(Int,Int)->(Int)，箭头前面括号是参数类型，多个参数逗号隔开，箭头后面括号返回值类型。
分析下上面代码，“=”左边的“ let add:(Int,Int)->(Int) ”意思是声明一个add常量，add是一个闭包类型，并且这个闭包的类型是：(Int,Int)->(Int)。
“=”右边是一个代码块，即闭包的具体实现，相当于给左边add常量赋值。代码块的语法格式：
{
(参数1，参数2) in
//code
}
参数和需执行的代码（code）用 关键字“in”隔开，如果闭包没有参数， “ () in”可以直接省略：
{
//code
}
你也可以用关键字“typealias”先声明一个闭包的数据类型
import UIKit
//声明一个闭包类型 AddBlock
typealias AddBlock = (Int,Int)->(Int);
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
let add:AddBlock = {
(a,b) in
return a + b;
}
let result = add(1100, 200);
print("result=\(result)");
}
}
3、闭包的用法和理解
1、两个类之间的通信
ios中类之间的通信方式有多种，常用的有：协议代理、通知，以及本章要讲的闭包。因为协议代理用起来比较麻烦，又是声明协议方法、又要设置代理的，代码步骤太多，我一般不用；通知一般用于两个完全没有关联的类通信，可以一对多，但解耦和的太厉害，我一般是特定的场合用。所以针对有关联的两个类之间的通信，我一般是用闭包或block的，这样比较简洁迅速。
示例程序：监听控制器上一个自定义view按钮的点击
界面效果
CustomView类中代码
class CustomView: UIView {
//声明一个属性btnClickBlock，type为闭包可选类型
//闭包类型：()->() ，无参数，无返回值
var btnClickBlock:(()->())?;
//重写 init(frame: CGRect)构造函数
override init(frame: CGRect) {
super.init(frame:frame);
//创建按钮
let btn = UIButton(frame: CGRect(x: 15, y: 15, width: 80, height: 32));
btn.setTitle("按钮", for: .normal);
btn.backgroundColor = UIColor.blue;
//绑定事件
btn.addTarget(self, action: #selector(CustomView.btnClick), for: .touchDown);
//添加
addSubview(btn);
}
//按钮点击事件函数
func btnClick(){
if self.btnClickBlock != nil {
//点击按钮执行闭包
//注意：属性btnClickBlock是可选类型，需要先解包
self.btnClickBlock!();
}
}
required init?(coder aDecoder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}
}
Controller类中代码：
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
//创建CustomView对象
let cutomeView = CustomView(frame: CGRect(x: 50, y: 50, width: 200, height: 200));
//给cutomeView的btnClickBlock闭包属性赋值
cutomeView.btnClickBlock = {
// () in 无参数可以省略
//当按钮被点击时会执行此代码块
print("按钮被点击");
}
cutomeView.backgroundColor = UIColor.yellow;
//添加到控制器view上
self.view.addSubview(cutomeView);
}
}
2、异步回调（callBack）
以发送一个简单的网络请求为例:
/// 定义一个网络请求函数
///
/// - parameter urlString: 请求接口 String
/// - parameter succeed: 成功的回调 可选闭包
/// - parameter failure: 失败的回调 可选闭包
func requestData(urlString:String,succeed: ((Any?)->(Void))?,failure:((Any?)->(Void))?){
let request = URLRequest(url: URL(string: urlString)!);
//发送网络请求
NSURLConnection.sendAsynchronousRequest(request, queue: OperationQueue()) { (_, data, error) in
if error == nil {
//请求成功，执行成功的回调，并把数据传递出去
succeed?(data);
}else{
//请求失败，执行失败的回调，并把错误传递出去
failure?(error);
}
}
}
// 调用函数requestData函数
requestData(urlString: succeed: { (data) -> (Void) in
//成功的回调
guard let result = data as? Data else{
return;
}
let srt = NSString(data: result, encoding: String.Encoding.utf8.rawValue);
print(srt!)
}) { (error) -> (Void) in
//失败的的回调
print(error);
}
四、闭包的一些特殊语法
1、尾随闭包
当闭包作为函数的最后一个参数时，可以省略前面的括号。尾随闭包没什么特殊的作用，纯粹是一种语法上的简洁，增加易读性。
例：定义一个函数：
//第二个参数：闭包 (String)->(Void)
func post(url:String,succesce:(String)->Void) {
print("发送请求");
succesce("请求完成");
}
执行函数，正常写法：
//正常写法，第二个参数，传递一个闭包
post("http", succesce: {
//闭包传递的参数
(json) in
//执行的代码
print(json);
});
执行函数，尾随闭包写法：
//尾随闭包，当闭包作为函数的最后一个参数时，可以省略前面的括号
HttpTool.post("http") { (json) in
print(json);
};
2、逃逸闭包
看起来很“吊炸天”的一个名字，其实很简单。当闭包作为一个参数传递到函数时，我们知道它一般是用于函数内部的异步回调，闭包是等异步任务完成以后才调用，而函数是会很快执行完毕并返回的，所以闭包它需要逃逸，以便稍后的回调。
逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。
或许细心的人已经发现我上面的示例网络请求为什么没有出现关键字“@escaping”，你可以拉回去看下成功回调或失败的回调，类型是“((Any?)->(Void))?”，后面带了个“？”，这是闭包可选类型，并不是闭包类型，所以无需关键字“@escaping”。
假设成功和失败的回调要弄成闭包类型，而你又要异步使用的话，那就要在形参前面加关键字，如下：
/// 定义一个网络请求函数
///
/// - parameter urlString: 请求接口 String
/// - parameter succeed: 成功的回调 闭包 因需要异步使用，前面加关键字@escaping修饰，指明其为逃逸闭包
/// - parameter failure: 失败的回调 闭包 因需要异步使用，前面加关键字@escaping修饰，指明其为逃逸闭包
func requestData(urlString:String,succeed: @escaping (Any?)->(Void),failure:@escaping (Any?)->(Void)){
let request = URLRequest(url: URL(string: urlString)!);
//发送网络请求
NSURLConnection.sendAsynchronousRequest(request, queue: OperationQueue()) { (_, data, error) in
if error == nil {
//请求成功，执行成功的回调，并把数据传递出去
succeed(data);
}else{
//请求失败，执行失败的回调，并把错误传递出去
failure(error);
}
}
}
- 捕获值
闭包可以在其定义的上下文中捕获常量或变量。
即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。
嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
看这个例子：
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
一个函数makeIncrementor ，它有一个Int型的参数amout, 并且它有一个外部参数名字forIncremet，意味着你调用的时候，必须使用这个外部名字。返回值是一个()-> Int的函数。
函数题内，声明了变量runningTotal 和一个函数incrementor。
incrementor函数并没有获取任何参数，但是在函数体内访问了runningTotal和amount变量。这是因为其通过捕获在包含它的函数体内已经存在的runningTotal和amount变量而实现。
由于没有修改amount变量，incrementor实际上捕获并存储了该变量的一个副本，而该副本随着incrementor一同被存储。
所以我们调用这个函数时会累加：
import Cocoa
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值为10
print(incrementByTen())
// 返回的值为20
print(incrementByTen())
// 返回的值为30
print(incrementByTen())
以上程序执行输出结果为：
10
20
30
- 闭包是引用类型
上面的例子中，incrementByTen是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
这是因为函数和闭包都是引用类型。
无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。 上面的例子中，incrementByTen指向闭包的引用是一个常量，而并非闭包内容本身。
这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
import Cocoa
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementor() -> Int {
runningTotal += amount
return runningTotal
}
return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值为10
incrementByTen()
// 返回的值为20
incrementByTen()
// 返回的值为30
incrementByTen()
// 返回的值为40
incrementByTen()
let alsoIncrementByTen = incrementByTen
// 返回的值也为50
print(alsoIncrementByTen())
以上程序执行输出结果为：
50