Swift 闭包表达式⑥

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

{
（参数列表）-> 返回值 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) in  v1 + 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)//-4



func 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()// 异步，可能不再函数作用域
    }
}

闭包

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

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

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 = 0
    
    return {
        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

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

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

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