Swift闭包、闭包简写、尾随闭包、逃逸闭包、自动闭包

闭包介绍

Swift闭包和Objective-C中的Block很类似，是一段自包含的函数代码块，可以在代码中使用和传递。相当于一个匿名函数。
函数：是一个有名字的闭包。
普通函数：是一个有名字但不会捕获任何值的闭包。
嵌套函数：是一个有名字并可以捕获其封闭函数域内值的闭包。

闭包格式

闭包表达式语法有如下的一般形式：

{ (parameters) -> returnType in
    statements
}

闭包使用、尾随闭包、闭包简写格式

// 以下闭包以Array的sorted函数为例
    func testClosure() {
        let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
        func backward(_ str1: String, _ str2: String) -> Bool {
            return str1 > str2
        }
        
        // sorted函数的参数是一个闭包，下面传了一个方法名，由此说明：嵌套函数是一个有名字但并可以捕获其封闭函数域内值的闭包
        var reversedNames = names.sorted(by: backward)
        
        // 普通闭包格式：(参数: 参数类型,...) -> 返回值类型 in ...
        reversedNames = names.sorted(by: {(_ str1: String, _ str2: String) -> Bool in return str1 > str2})
        
        // 根据Swift的类型推断，参数类型及参数括号可以去掉，返回值类型可以去掉
        reversedNames = names.sorted(by: {str1, str2 in return str1 > str2})
       
        // 单行表达式：可以去掉return
        reversedNames = names.sorted(by: {str1, str2 in str1 > str2})
        
        // 使用参数名缩写：参数和in也可以去掉
        reversedNames = names.sorted(by: {$0 > $1})
       
        // 使用运算符：因为Swift中为字符串重载了大于号小于号
        reversedNames = names.sorted(by: >)
        
        // 使用尾随闭包：前提是闭包必须是函数的最后一个参数
        reversedNames = names.sorted() {$0 < $1}
        
        // 使用尾随闭包：闭包是函数唯一参数时，可以省掉参数括号
        reversedNames = names.sorted {$0 < $1}
        
        print(reversedNames)
    }

闭包值捕获，闭包是引用类型

先贴代码：

// 值捕获示例：下面嵌套函数incrementer本身没有参数，它却捕获了外围的参数runningTotal和amount
    func makeIncrementer(forIncrement amount: Int) -> () -> Int {
        var runningTotal = 0
        func incrementer() -> Int {
            runningTotal += amount
            return runningTotal
        }
        return incrementer
    }

// 调用
let makeIncrementByTen = makeIncrementer(forIncrement: 10)
        var ret = makeIncrementByTen()
        print("ret= \(ret)")// ret= 10
        ret = makeIncrementByTen()
        print("ret= \(ret)")// ret= 20
        ret = makeIncrementByTen()
        print("ret= \(ret)")// ret= 30
        
        let makeIncrementBySeven = makeIncrementer(forIncrement: 7)
        ret = makeIncrementBySeven()
        print("ret= \(ret)")// ret= 7
        
        ret = makeIncrementByTen()
        print("ret= \(ret)")// ret= 40
        
        // 上面的同一个闭包连续调用，值会递增原因：闭包是引用类型，同一个闭包捕获的变量并没有释放

逃逸闭包

逃逸闭包概念：当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。逃逸闭包多用来做函数回调，与Objective-C里的Block有异曲同工之妙。
代码示例：

// 逃逸闭包示例：下面的闭包被方法外的数组引用，也就意味着，这个闭包在函数执行完后还可能被调用，所以必须使用逃逸闭包，不然编译不过去
    var completionHandlers: [() -> Void] = []
    func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
        completionHandlers.append(completionHandler)
    }
// 非逃逸闭包
    func someFunctionWithNoneEscapingClosure(closure: () -> Void) {
        closure()
    }

    var x = 10
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib. 
        // 逃逸闭包
        someFunctionWithEscapingClosure {
            // 注意：逃逸闭包类必须显式的引用self，
            self.x = 100
        }
        someFunctionWithNoneEscapingClosure {
            x = 200
        }
        print("x= \(x)")// x= 200
        completionHandlers.first?()
        print("x= \(x)")// x= 100
    }

自动闭包

自动闭包：闭包作为参数传递给函数时，可以将闭包定义为自动闭包（使用关键字@autoclosure）。这样传递参数时，可以直接传递一段代码（或者一个变量、表达式），系统会自动将这段代码转化成闭包。需要注意：过度使用 autoclosures 会让你的代码变得难以理解。这里不贴代码了。