一、闭包的介绍
闭包是指可以包含自由（未绑定到特定对象）变量的代码块。解释：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）。
二 、闭包的形式
闭包函数名： 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("逃逸闭包")
}
