关于如何理解闭包

学习闭包的第一个难点就是理解闭包，可能很多人用了很久的闭包都还不太清楚闭包到底是什么，我这里提供一种理解思路，仅供参考。
对于很多iOS开发者来说一开始接触到Swift闭包会试图用OC中的Block去理解，当然这会对我们的理解有一定帮助，就好比很多人学习英语：tomato->西红柿->🍅，而不是tomato-> 🍅，而一个婴儿刚开始接触语言时候就是直接由tomato的发音联想到🍅，而后再去学习🍅的单词拼写，这是人类与生俱来的学习语言的逻辑流程，所以我们不妨按照这种思维逻辑去学习和理解Swift的闭包。
1、闭包是什么
这就好比一个婴儿好奇西红柿是什么，家长会将一个真实的西红柿拿到他的面前，看一看，摸一摸，闻一闻，尝一尝。对于Swift的闭包，我们首先不需要知道是它在语法上如何定义的，而是要知道闭包的本质。
闭包的本质是代码块，它是函数的升级版本，函数是有名称、可复用的代码块，闭包则是比函数更加灵活的匿名代码块。
2、为什么需要闭包
当一个婴儿知道了西红柿是什么，自然而然就会想到西红柿有什么用，那么我们自然也会问闭包在Swift中有何用处呢？
函数已经可以满足我们开发中大部分的需求了，那么为什么还需要闭包呢。在开发中我们经常需要传递各种数据，我们习惯了传递一个值：Int，一串符号：String，一个对象：Class，但是有时我们需要传递一种处理问题的逻辑，我们常用的类型似乎满足不了这种需求，而函数恰好是一种处理问题的逻辑，为了让函数像Int、Float、String等常用类型一样灵活的传递和调用，闭包就出现了。
综上所述，我们可以知道闭包本质上和函数一样都是代码块，而闭包更加灵活。
闭包、嵌套函数、函数
更好地使用闭包前需要理清3者的联系和区别
首先看3种函数的定义：

􏰱􏰲􏲁􏰵􏲊􏲋􏱰􏱱􏰷􏲌􏲍􏰸􏲎􏰵􏲏􏲐􏲑􏱁􏱯􏰛􏱘􏱰􏱱􏲒􏱛􏲓􏲔􏲕􏲖 􏲗􏱬􏱁//函数
func eatTomatos(a: Int, b: Int) -> Int {
    return a + b
}

//嵌套函数
func eatTomatos(a: Int, b: Int) -> Int {
    //嵌套函数
    func digest(a: Int, b: Int) -> Int {
        return 2 * a + b
    }
    
    return digest(a: a, b: b)
}

//闭包
var eatTomatos = {(a: Int, b: Int) -> Int in
    return a + b
}

从上面的定义可以看出函数和嵌套函数其实是一回事，唯一的区别是，嵌套函数是定义在一个函数内部的函数，对外部是隐藏的，只能在其定义的函数内部有效。而闭包与函数的不同要多一些：1、不需要使用func关键字，2、其次函数有名称如：eatTomatos，而闭包是没有名称的，3、闭包的参数和函数体都要使用{ }包起来，在参数后要使用in关键字连接函数体，4、闭包可以作为一种类型赋值给一个变量，上面代码中的闭包类型是： (Int, Int) -> Int 。
上面从定义上分析了3者的不同，下面从功能上区分下。
1、函数是全局的，不能捕获上下文中的变量；而嵌套函数和闭包可以直接嵌套在上下文中使用的，因此可以捕获上下文中的变量，需要注意的是每一个闭包都只会持有一个它所捕获的变量的副本，如下：

override func viewDidLoad() {
    super.viewDidLoad()
    print(eatTomatos(a: 1, b: 2))//③
    print(eatTomatos(a: 2, b: 3))//④
}

func eatTomatos(a: Int, b: Int) -> Int {
    var numArray: Array<Int> = Array.init()
    
    //嵌套函数
    func digest(a: Int, b: Int) -> Int {
        numArray.append(a)
        numArray.append(b)
        print(numArray.count)//②
        return 2 * a + b
    }
    
    print(numArray.count)//①
    
    return digest(a: a, b: b)
}

//打印的结果依次（①②③④）是：
0
2
4
0
2
7

2、闭包可以作为参数或者返回值，如下：

// 作为参数
override func viewDidLoad() {
    super.viewDidLoad()
    cookTomates { (a, b) in
        print(a)
        print(b)
    }
}

func cookTomates(tomato: (Int, Int) -> Void){
    tomato(1, 2)
}

cookTomates函数将闭包(Int, Int) -> Void作为参数，并且可以在函数内部操作这个闭包
在调用cookTomates函数式需要将给这个闭包参数赋值，并且闭包中的参数名需要调用的时候自行命名。

//作为返回值
override func viewDidLoad() {
    super.viewDidLoad()
    
    let tomato = gainTomatos()
    print(tomato(2, 3))
    
}
var eatTomatos: (Int, Int) -> Int = {(a: Int, b: Int) -> Int in
    return a + b
}
func gainTomatos() -> (Int, Int) -> Int {
    return eatTomatos
}

函数gainTomatos将闭包(Int, Int) -> Int作为返回值，这里返回的是(Int, Int) -> Int的一个实例，调用者便可以利用返回的实例获取(Int, Int) -> Int闭包处理参数的逻辑，实现代码的传递和复用
为你的闭包类型起别名
闭包类型不像其他常用类型看起来比较简洁，有参数、返回值、关键字、符号构成，影响阅读和纠错，因此为常用的闭包类型起一个别名很有必要。

如下，为(Int, Int) -> Int闭包类型起别名
typealias Tomato = (Int, Int) -> Int

因此上面闭包当做返回值使用的代码便可以改写如下：

override func viewDidLoad() {
    super.viewDidLoad()
    
    let tomato = gainTomatos()
    print(tomato(2, 3))
    
}

var eatTomatos: Tomato = {(a: Int, b: Int) -> Int in
    return a + b
}

func gainTomatos() -> Tomato {
    return eatTomatos
}

当我们把(Int, Int) -> Int类型抽象为Tomato后，不仅仅是代码看起来更加简洁，也更接近我们使用的其他参数类型，更加便于理解
闭包传值
OC中常用的传值方法有代理、Block、通知等，对应到Swift Block就由闭包替代。
如下需要使用闭包将B中的a、b值传递到A中

override func viewDidLoad() {
    super.viewDidLoad()
    
    let a: A = A()
    a.fromB()
    
}

typealias Tomato = (Int, Int) -> Int

class A: NSObject {
    let b: B = B()
    
    func fromB() {
        b.tomato = {
            (x, y) -> Int in
            return x + y
        }
        print(b.toA())
    }
    
}

class B: NSObject {
    var tomato: Tomato?
    
    func toA() -> Int {
        let a = 3
        let b = 4
        return tomato!(a, b)
    }
    
}

由上可以总结出闭包传值的流程：

1️、首先为自己的闭包类型起一个别名，便于使用；
2️、在需要把值传递给另外一个对象的类里声明一个闭包类型的变量，对应到上面的代码中就是B；
3️、在需要接收值的类里为闭包类型赋值，从而在此闭包内便可以获取传递的值。

注意：

这里着重描述传值的流程，在开发的时候还需判断闭包是否为nil，否则会导致崩溃；

闭包作为参数传值

在使用AFN或者SDWebImage的时候，通过Block获取请求的数据很方便，那么在Swift中如何使用闭包实现这种效果呢。
其实上面在说闭包作为参数使用的时候，已经实现了这种传值的方式，这里举另外一个例子，我们在使用第三方库的时候通常会将其再封装一次，避免由于第三方库不维护或者出现较大更新的时候增加不必要的工作量，这里以简单封装Alamofire为例，代码如下：

import UIKit
import Alamofire
import SwiftyJSON

class ZYLResponse: NSObject {
    //接收数据是否成功
    var isSuccess: Bool = false
    //接收到的字典数据
    var dict: Dictionary<String, Any>?
    //接收到的数组数据
    var array: Array<Any>?
    //错误信息
    var error: Error?
    //JSON
    var json:JSON?
    
}

typealias DataReply = (ZYLResponse) -> Void

class ZYLNetTool: NSObject {
    
    ///POST请求
    open static func post(url: String, parameters: Dictionary<String, Any>?, complete: @escaping DataReply) {
        Alamofire.request(url, method: .post, parameters: parameters).responseJSON { (response) in
            let myResponse = ZYLResponse()
            myResponse.isSuccess = response.result.isSuccess
            myResponse.dict = response.result.value as! Dictionary<String, Any>?
            myResponse.array = response.result.value as? Array<Any>
            myResponse.error = response.result.error
            myResponse.json = JSON(data: response.data!)
            
            complete(myResponse)
        }
    }
    
    ///GET请求
    open static func get(url: String, parameters: Dictionary<String, Any>?, complete: @escaping DataReply) {
        Alamofire.request(url, method: .get, parameters: parameters).responseJSON { (response) in
            let myResponse = ZYLResponse()
            myResponse.isSuccess = response.result.isSuccess
            myResponse.dict = response.result.value as! Dictionary<String, Any>?
            myResponse.array = response.result.value as? Array<Any>
            myResponse.error = response.result.error
            myResponse.json = JSON(data: response.data!)
            
            complete(myResponse)
        }
    }
    
}

//调用
ZYLNetTool.post(url: HTTP_ACTIVATE_PORT, parameters: paraDict, complete: { (response) in
    if response.isSuccess {
        //请求数据成功
        
    } else {
        //请求数据失败
        
    }
})

注意：
1、使用闭包时要注意管理内存；
2、当作闭包为函数参数使用时可以脱离函数独立使用时，要将此闭包声明为逃逸闭包，在参数类型前面加上@escaping，否则会报错。

总结

接触一种新的事物之前总会觉得很难，当我们学会后发现其实很简单，难的不是这个新事物本身，而是我们的大脑出于习惯很难接受新的事物，总是需要一定的过程。记得学C语言时很难理解指针，学C++时很难理解面向对象，学OC时很难理解Block，而Swift作为一种新的语言，必然会有很多新的事物让我们难以理解，比如闭包、元组、可选类型、函数式编程等等，以上就是这篇文章的全部内容了，本文只对闭包发表一点拙见，如果有什么不足的地方还望指正，谢谢。