闭包

闭包表达式

在Swift中  可以通过func定义一个函数 也可以通过闭包表达式定义一个函数

{
     （参数列表） ->  返回值类型 in 
      函数体代码
}

尾随闭包

如果将一个很长的闭包表达式作为函数的最后一个实参 就叫做尾随闭包
使用尾随闭包可以增强函数的可读性

func exec(_ v1: Int,_ v2: Int, fn:(Int, Int) -> Int)  {
    print(fn(v1,v2))
}

exec(10,20){
    $0 + $1
}

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

func test(fn: (Int,Int) -> Int){
    print(fn(1,2))
}

test(fn:{
    $0 + $1
})

test() {
    $0 + $1
}

test {
  $0 + $1
}

数组的排序

系统方法
  //从小到打大
    arr.sort()

// 返回true  i1排在i2前面
// 返回false i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
    //大的排前面
    return i1 > i2
}

func testSort() {
    var arr = [10,1,4,20,99]
    arr.sort(by: cmp)
    print(arr)
}

testSort()

尾随闭包
var arr = [10,1,4,20,99]
arr.sort {
    $0 < $1
}

print(arr)

var arr = [10,1,4,20,99]

arr.sort(by: <)
print(arr)

忽略参数

func test(fn: (Int,Int) -> Int){
    print(fn(1,2))
}

test {
    _,_ in 10
}

直接返回10

闭包

 一个函数和它所捕获的常量/变量环境组合起来 成为闭包
   - 一般指定义在函数内部的函数
   - 一般它捕获的是外层函数的局部变量/常量

typealias Fn = (Int) -> Int

func getFn() -> Fn {
    //局部变量
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
//返回的plus 和 num 形成了闭包
}

var fn = getFn()
print(fn(1))
print(fn(2))
print(fn(3))
print(fn(4))

堆空间分配 如果没有赋值 里面就是垃圾数据
bt 打印函数调用栈
捕获值的时候 是在函数开始到return之前

可以把闭包想象成一个类的实例对象
   - 内存在堆空间
   - 捕获的局部变量/常量就是对象的成员 (存储属性)
   - 组成闭包的函数就是类内部定义的方法

rax rdx放函数返回值

如果返回值是函数类型 那么参数的修饰要保持统一

func add(_ num: Int) -> (inout Int) -> Void {
func plus(v: inout Int) {
V += num
}
return plus
}
var num=5
add (20) (&num)
print (num) 

自动闭包 @autoclosure

func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int {
    return v1 > 0 ? v1 : v2()
}

getFirstPositive(10, 20)

@autoclosure 会把v2 自动封装成闭包
并非只支持最后1个参数
空合并运算符使用了@autoclosure 技术

只支持() -> T 格式的参数
有@autoclosure 和 无@autoclosure的函数 构成了函数重载
为了避免和期望冲突 使用了@autoclosure的地方最好明确注释清楚 这个值会被推迟执行