swift闭包与闭包表达式

首先来说一下闭包和闭包表达式的定义：
闭包：一个函数和它所捕获的变量\常量环境组合起来，称为闭包
1、一般指定义在函数内部的函数
2、一般它捕获的最外层函数的局部变量\常量
列子：

typealias Fn = (Int) -> Int
func getFn() -> Fn {
    var num = 0
    func plus(_ i: Int) -> Int {
        num += I
        return num
     }
     return plus
} // 返回的plus和num形成了闭包
var fn1 = getFn()
var fn2 = getFn()
fn1(1) // 1
fn2(2) // 2
fn1(3) // 4
fn2(4) // 6
fn1(5) // 9
fn2(6) // 12

大家有没有发现其实闭包像一个类的实例对象

class Closure {
    var num = 0
    func plus(_ i: Int) {
        num += I
        return num
     }
}
var cs1 = Closure()
var cs2 = Closure()
cs1.plus(1) // 1
cs2.plus(2) // 2
cs1.plus(3) // 4
cs2.plus(4) // 6
cs1.plus(5) // 9
cs2.plus(6) // 12

闭包表达式：
{
(参数列表) -> 返回值类型 in
函数体代码
}
如：

var fn = {
    (v1: Int, v2: Int) -> Int in
     return v1 + v2
}
fn(10, 20)

尾随闭包：
1、如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性
2、尾随闭包是一个被书写在函数调用括号外面（后面）的闭包表达式
3、如果闭包表达式是函数的唯一实参，而且使用了尾随闭包的语法，那就不需要在函数名后面写圆括号

func exec(fn: (Int, Int) -> Int) {
    print(fn(1, 2))
}
exec(fn: { $0 + $1 })
exec() { $0 + ￥1 }
exec { $0 + $1 }

自动闭包：

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

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

为了避免与期望冲突，使用了@autoclosure的地方最好明确注释清楚：这个值会被推迟执行
逃逸闭包：
闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明

// fn是逃逸闭包
var gFn: Fn?
func test(_ fn: @escaping Fn) { gFn = fn }