Swift 中的闭包

1. 闭包表达式语法

{ (parameters) -> returnType in
    statements
}

下面是利用闭包对数组进行反向排序的一个例子：

let names = ["Chris", "Alex", "Ewa", "Barry", "David"]
let reservedNames = names.sorted { (s1: String, s2: String) -> Bool in
    return s1 > s2
}
print(reservedNames)
// print "["Ewa", "David", "Chris", "Barry", "Alex"]"

2. 根据上下文推断类型

上文中的参数类型和返回类型都可以被正确推断，因此可以简写为如下形式：

let reservedNames = names.sorted { s1, s2 in return s1 > s2 }

3. 单表达式闭包返回

单行表达式闭包可以省略关键字 return ，上例可以进一步简写为：

let reservedNames = names.sorted { s1, s2 in s1 > s2 }

4. 参数名称缩写

Swift 自动为内联闭包提供参数名称缩写功能，可以直接通过 $0， $1， $2 来顺序调用闭包的参数，以此类推。

如果使用缩写的参数名称，可以在闭包定义中省略参数列表，Swift 会自动推断参数类型。in 关键字也可以被省略，因此上例的极简写法如下：

let reservedNames = names.sorted { $0 > $1 }

5. 尾随闭包

如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。

尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个函数调用。在使用尾随闭包时，不用写出它的参数标签。

let reservedNames = names.sorted() { $0 > $1 }

当闭包表达式是函数或方法的唯一参宿时，可以省略 () ：

let reservedNames = names.sorted { $0 > $1 }

6. 值捕获

func makeIncremeter(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incremeter() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incremeter
}

let incrementByTen = makeIncremeter(forIncrement: 10)
incrementByTen() // return 10
incrementByTen() // return 20
incrementByTen() // return 30

incrementer() 是一个嵌套函数，它从外围函数捕获了 runningTotal 和 amount 变量的引用。捕获引用保证了 runningTotal 和 amount 变量在调用完 makeIncrementer 后不会消失，并且保证了在下一次执行 incrementer函数时， runnningTotal 依旧存在。

如果你创建了另一个 incrementer ，它会有属于自己的引用，指向一个全新、独立的 runningTotal 变量：

let incrementByFive = makeIncremeter(forIncrement: 5)
incrementByFive()  // return 5
incrementByFive()  // return 10

再看看下面的代码：

let alsoIncrementerByTen = incrementByTen
alsoIncrementerByTen() // return 40

这说明 alsoIncrementerByTen 和 incrementerByTen 指向的是同一个闭包，说明闭包时引用类型。

7. 逃逸闭包

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸，我们在参数名之前标注 @escaping 来表明这个闭包时允许“逃逸”出这个函数的。

一种能使闭包“逃逸”出函数的方法是，将这个闭包保存在一个函数外部定义的变量中。下面这个例子中的闭包会在函数返回之后才被调用：

var completionHandles: [() -> Void] = []
func someFunctionWithEscapinClosure(completionHandler: @escaping () -> Void) {
    completionHandles.append(completionHandler)
}

将一个闭包标记为 escaping 意味着你必须在闭包中显式地引用 self 。而非逃逸闭包，可以隐式地引用 self 。

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapinClosure {
            self.x = 100
        }
        someFunctionWithNonescapingClosure {
            x = 200
        }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x) // print "200"

completionHandles.first?()
print(instance.x) // print "100"

8. 自动闭包

自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。它不接受任何参数，当它被调用时，会返回被包装在其中的表达式的值。自动闭包只有被调用的时候，代码才会延迟执行。

var arr = [1, 2, 3, 4, 5]
print(arr.count) // print "5"

let cl = { arr.remove(at: 0) }
print(arr.count) // print "5" , 说明闭包并没有执行

print("Now remove \(cl())") // print "Now remove 1", 此时调用了自动闭包
print(arr.count) // print "4"

注：
cl 的类型不是 Int ，而是 () -> Int ，一个没有参数且返回值为 Int 的函数。

将闭包作为参数传递给函数时，同样能获得延时求值行为。

func cl(element removeElement: () -> Int) {
    print("Now remove \(removeElement())")
}

cl { () -> Int in
    arr.remove(at: 0)
}
// print "Now remove 2"

上面的 cl 函数接受一个返回移除元素的显式的闭包。下面的例子完成了相同的操作，不过它并没有接受一个显式的闭包，而是通过将参数标记为 @autoclosure 来接收一个自动闭包。现在你可以将该函数当做接受 Int 类型参数（而非闭包）的函数来调用，removeElement 参数将自动转化为一个闭包。

func cl2(remove removeElement: @autoclosure () -> Int) {
    print("Now remove \(removeElement())")
}

cl2(remove: arr.remove(at: 0))
// print "Now remove 3"

如果你想让一个自动闭包可以“逃逸”，则应该同时使用 @autoclosure 和 escaping 关键字。