一、闭包的介绍

闭包是指可以包含自由（未绑定到特定对象）变量的代码块。解释：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）。

二 、闭包的形式

     闭包函数名： A 
     参数1 ：    B
     参数2 ：    C
     参数1、2 的类型:  D
     返回值的类型 ： E
     
     则闭包的样式为：
     
     A : (_ B:D ,_ C:D)-> E
     
     例如：  let  sum : (_ index :Int) -> Int
     
     其中： B/C/E 三个可以有无。特殊情况下 A 也可以没有，但是一般都有的。

三 、闭包的几种形式

1> 无参数，无返回值

// TODO : 无返回值的、无参数的闭包
let ClosureModel_1 : ()->() = {
    print("无返回值的、无参数的闭包")
}
// 调用闭包
ClosureModel_1()

2> 有参数无返回值的闭包

// TODO : 有参数、无返回值的闭包
let ClosureModel_2 : (_ index:Int)->() = { index in
    print("我输入的数值:"+"\(index)")
}
// 调用闭包
ClosureModel_2(120)

3> 多个参数无返回值的闭包

// TODO : 多个参数、无返回值
let ClosureModel_3 : (_ index:Int,_ index_1:Int)->() = { (index,index_1) in
    print("两个数的和为:" + "\(index + index_1)")
}
// 调用函数
ClosureModel_3(110,120)

4> 无参数有返回值的闭包

// TODO : 无参数、有返回值
let ClosureModel_4 :()->Int = {
    return 110
}
// 调用
print("无参数有返回值的调用结果：" + "\(ClosureModel_4())")

5> 有参数有返回值的闭包

// TODO : 有参数，有返回值
let ClosutreModel_5 : (_ index:Int)->Int = { (index:Int) in
    let temp = 200
    return temp * index
}
// 调用
print("有参数返回值的调用结果:" + "\(ClosutreModel_5(110))")

四、使用别名(typealias)来创建闭包

1> 无参数无返回值的闭包

typealias ClosureModel_6 = ()->()

// 创建一个变量
let Closure :ClosureModel_6 = {
    print("使用别名创建闭包")
}
// 调用
Closure()

2> 有参数有返回值

typealias ClosureModel_7 = (_ index:Int)-> Int

// 创建一个变量
let Closure1:ClosureModel_7 = { index in
    let temp = 100
    return temp * index
}
// 调用
print("别名有参数返回值的调用：" + "\(Closure1(20))")

五、尾随闭包

1> 什么是尾随闭包？

尾随闭包是指闭包作为函数的最后一个参数，称为尾随闭包。

2> 带有参数和返回值的尾随闭包

// TODO : 尾随闭包,带有参数和返回值的

func sum(index:Int,max:(_ value:Int,_ kvalue:Int)->Int) -> Int {
     return  max(index,index)
}

// MARK : 尾随闭包的调用
print(sum(index: 3){ closure,closure_k in
    return closure * closure_k
})

3> 无参数和返回值的尾随闭包

// TODO : 尾随闭包，不带参数和返回值

func reduction(index:Int,index1:Int,max:()->()) -> Int {
     max()
     return index - index1
}

//  闭包的调用
print(reduction(index: 100, index1: 20){
    print("尾随闭包无参数和返回值")
})

六 、闭包取值

// MARK : 闭包值的捕获

func getValue(param value:Int) -> ()->Int {
    var toale = 0
    func max()->Int {
        toale += value
        return  toale
    }
    return max
}

// MARk : 闭包值的捕获调用
print(getValue(param: 10)())   // 输出  10
print(getValue(param: 10)())   // 输出  10 
注释： 这样输出，都是从新创建的闭包(新的闭包)，所以值一样.

// 创建一个常量
let paramValue = getValue(param: 10)
print(paramValue())  // 输出  10
print(paramValue()) //  输出  20

七、自动闭包

1> 自动闭包的特点

• 自动闭包是一种自动创建的闭包，用于包装函数参数的表达式
• 自动闭包是不接受任何参数，被调用时返回包装在其中的表达式
• 自动闭包能够延迟加载求值

2> 自动闭包的使用

var ParamArray = ["2","3","4"]
// 获取数组元素的个数
print(ParamArray.count)
// 创建自动闭包
let removeSwift = {
    ParamArray.remove(at: 2)
}
// 再获取数组元素的个数
print(ParamArray.count)
// 调用自动闭包
print(removeSwift())
// 再次获取数组元素的个数
print(ParamArray.count)

八、逃逸闭包

1> 逃逸闭包的解释

当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。

2> 闭包的使用

// TODO : 逃逸闭包
func doSomething(some: @escaping () -> Void){
    //延时操作，注意这里的单位是秒
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1) {
        //1秒后操作
        some()
    }
    print("函数体")
}

doSomething {
    print("逃逸闭包")
}