Swift|Swift 闭包表达式⑥ Swift闭包表达式⑥

?在Swift中定义一个函数有两种方式
??1. 可以通过func定义一个函数
??2. 通过闭包表达式
闭包格式：

【Swift|Swift 闭包表达式⑥】{
（参数列表）-> 返回值 in
? 函数体代码
}

示例：

//函数 func sum(_ v1 : Int , _ v2 : Int) -> Int { return v1 + v2 } print(sum(1, 2)) //3//闭包1 var fn = { (v1 : Int , v2 : Int) -> Int in return v1 + v2 } print(fn(1,2)) //3 //闭包2 print({ (v1 : Int , v2 : Int) -> Int in return v1 + v2 }(20,30)) //50

1. 闭包表达式的简写

//函数定义 func exec(v1: Int, v2: Int , fn: (Int, Int) -> Int){ print(fn(v1,v2)) } //调用 exec(v1: 10, v2: 20, fn: { (v1, v2) -> Int in return v1 + v2 })//2 exec(v1: 10, v2: 20, fn: { (v1, v2) in return v1 + v2 } ) //3 exec(v1: 10, v2: 20, fn: { (v1, v2) inv1 + v2 //如果函数体代码就是一个单一的表单时，则return可以胜率 } ) //4 exec(v1: 10, v2: 20, fn: {$0 + $1})//$0 第一个参数//5 exec(v1: 10, v2: 20, fn: + )

2. 尾随闭包

如果将一个很长的闭包表达式座位函数的最后一个实参，使用尾随闭包可以增强函数的可读性
尾随闭包是一个呗书写在函数调用括号外面（后面）的闭包表达式

exec(v1: 10, v2: 20){ (v1, v2) -> Int in return v1 + v2 }exec(v1: 10, v2: 20){$0 + $1}

如果闭包表达式是函数唯一实参，而且使用了尾随闭包的语法，那就不需要在函数后面写圆括号

func execc(fn : (Int, Int) -> Int){ print(fn(1,2)) }execc(fn: { (v1, v2) -> Int in return v1 + v2 } )execc { (v1, v2) -> Int in return v1 + v2 }execc{$0 + $1}

3. 自动闭包
为了避免与期望冲突，使用了@autoclosure 的地方最好明确注释清楚：这个值会被推迟执行

func getFirstPositive(_ v1: Int, _ v2: Int) -> Int { return v1 > 0 ? v1 : v2 }getFirstPositive(10, 20)//10 getFirstPositive(-2, 20)//20 getFirstPositive(0, -4)//-4func sum( ) -> Int { let a = 10 let b = 10 return a + b } getFirstPositive(10, sum())//对于这种情况，即便v1>0,后面的sum还是会执行，浪费资源

//优化 func getFirstPositive2(_ v1: Int, _ v2: ()->Int) -> Int { return v1 > 0 ? v1 : v2() }getFirstPositive2(10, {20})//10 getFirstPositive2(-2, {20})//20 getFirstPositive2(0, {-4})//-4

//autoclosure自动闭包延迟加载 func getFirstPositive2(_ v1: Int, _ v2: @autoclosure()->Int) -> Int { return v1 > 0 ? v1 : v2() }getFirstPositive2(10, 20)//10 getFirstPositive2(-2, 20)//20 getFirstPositive2(0, -4)//-4 getFirstPositive2(2, sum())

@autoclosure 会自动将20 封装成闭包 {20}
@autoclosure 只支持 ()-> T 格式的参数
@autoclosure 并非只支持最后一个参数
空合并运算符?? 使用了- @autoclosure技术
有 @autoclosure 和无@autoclosure构成了函数重载

4. 非逃逸闭包、逃逸闭包
非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数

非逃逸闭包 ：闭包调用发生在函数结束之前，闭包调用在函数作用域内
逃逸闭包 ：闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping 声明

typealias Fn = () -> () //fn 是非逃逸闭包 func test1(_ fn : Fn){ fn() }var gFn : Fn? //fn 是逃逸闭包 func test2(_ fn: @escaping Fn){ gFn = fn }//fn 是逃逸闭包 func test3(_ fn: @escaping Fn) { DispatchQueue.global().async { fn()// 异步，可能不再函数作用域 } }

闭包

一个函数和它所捕获的变量/常量环境组合起来。称为闭包，

一般指定义在函数内部的函数。
一般它捕获的是外层函数的局部变量/常量

typealias Fn = (Int) -> Int func getFn() -> Fn{ //局部变量 num var num = 0 func plus(_ i:Int) -> Int{ //被捕获后，会在堆空间分配一个内存用来存储num num += i return num } return plus// 返回的plus 跟捕获的 num 组合起来叫做闭包，getFn只是一个函数 } // 上面闭包的简写方式 func getFnS() -> Fn{ var num = 0return { num += $0 return num } }var fn1 = getFn() var fn2 = getFn() print(fn1(1))//1 print(fn2(2))//2 print(fn1(3))//4 print(fn2(4))//6

可以把闭包想象成一个类的实例对象

内存在堆空间
捕获的局部变量/常量就是对象的成员（存储属性）
组成闭包的函数就是类内部定义的方法

class Closure { var num = 0 func plus(_ i: Int) -> Int { num += i return num }}var c1 = Closure() var c2 = Closure()c1.plus(1)//1 c2.plus(2)//2 c1.plus(3)//4 c2.plus(4)//6