指南：闭包（Closures）

• 全局函数是一个有名字但不会捕获任何值的闭包
• 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
• 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

闭包表达式（Closure Expressions）

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

{ (parameters) -> returnType in
    statements
}

• 闭包表达式语法可以使用常量、变量和inout类型作为参数，不能提供默认值。也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。
• 如果可以推断出参数和返回值的类型，这些类型都可以省略。返回箭头（->）和围绕在参数周围的括号也可以被省略。
• 单行表达式闭包可以通过省略return关键字来隐式返回单行表达式的结果。
• Swift 自动为内联闭包提供了参数名称缩写功能，可以直接通过$0，$1，$2来顺序调用闭包的参数，以此类推。
• 如果在闭包表达式中使用参数名称缩写，可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。in关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成。
• Swift 的String类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值。而这正好与sort(_:)方法的参数需要的函数类型相符合。因此，您可以简单地传递一个大于号，Swift 可以自动推断出您想使用大于号的字符串函数实现。

在这里，>相当于一个函数名，代表了一个函数（运算符函数），这里刚好凑上（类型符合）。这种情况是特例，不具有通用性。

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func backwards(s1: String, s2: String) -> Bool {
    return s1 > s2
}
var reversed = names.sort(backwards)
// reversed 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

reversed = names.sort({ (s1: String, s2: String) -> Bool in
    return s1 > s2
})

reversed = names.sort( { s1, s2 in return s1 > s2 } )

reversed = names.sort( { s1, s2 in s1 > s2 } )

reversed = names.sort( { $0 > $1 } )

reversed = names.sort() { $0 > $1 }

reversed = names.sort { $0 > $1 }

reversed = names.sort(>)

在实际的使用中，是否需要这么省略，值得商量。毕竟可读性还是首先要考虑的，少写几个字母，意义并不是很大。不过，这种利用类型推断让人偷懒的做法，还是挺有新意的。

尾随闭包（Trailing Closures）

• 如果需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。
• 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
• 如果函数只需要闭包表达式一个参数，当使用尾随闭包时，甚至可以把()省略掉：

let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map {
    (number) -> String in
    var number = number
    var output = ""
    while number > 0 {
        if let name = digitNames[number % 10] {
            output = name + output
            number /= 10
        }
    }
    return output
}
// strings 常量被推断为字符串类型数组，即 [String]
// 其值为 ["OneSix", "FiveEight", "FiveOneZero"]

宁可累一点，用if let 结构，也不要用！显示表达对可选类型的处理过程。

捕获值（Capturing Values）

• 闭包可以在其被定义的上下文中捕获常量或变量。
• 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
• Swift 会负责被捕获变量的所有内存管理工作，包括释放不再需要的变量。
• 如果将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，将创建一个在闭包和该实例间的循环强引用。Swift 使用捕获列表来打破这种循环强引用。

关于引用循环，Swift的处理方式比较复杂，感觉不是很好

• 函数和闭包都是引用类型。无论将函数或闭包赋值给一个常量还是变量，实际上都是将常量或变量的值设置为对应函数或闭包的引用。

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
let incrementBySeven = makeIncrementor(forIncrement: 7)
let alsoIncrementByTen = incrementByTen

incrementByTen()
// 返回的值为10
incrementByTen()
// 返回的值为20
incrementByTen()
// 返回的值为30
incrementBySeven()
// 返回的值为7
incrementByTen()
// 返回的值为40
alsoIncrementByTen()
// 返回的值为50

感觉有点像静态局部变量，还有类的实例变量隔离的作用。

非逃逸闭包(Nonescaping Closures)

• 当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。

可以理解为异步，先离开函数，等某件事完成之后，再来执行闭包。Object-C中的Block基本上是这样的

• 当定义接受闭包作为参数的函数时，在参数名之前标注@noescape，用来指明这个闭包是不允许“逃逸”出这个函数的。闭包只能在函数体中被执行，不能脱离函数体执行.

可以理解为同步，先执行完闭包，再离开函数。

func someFunctionWithNoescapeClosure(@noescape closure: () -> Void) {
    closure()
}
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: () -> Void) {
    completionHandlers.append(completionHandler)
}
class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNoescapeClosure { x = 200 }
    }
}

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

completionHandlers.first?()
print(instance.x)
// prints "100"

闭包默认是异步的（可逃逸的）；加@noescape关键字，就是同步的（不可逃逸的）

自动闭包（Autoclosures）

• 自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。
• 这种闭包不接受任何参数，当它被调用的时候，会返回被包装在其中的表达式的值。
• 这种便利语法能够用一个普通的表达式来代替显式的闭包，从而省略闭包的花括号。
• 闭包能够延迟求值，因为代码段不会被执行直到调用这个闭包为止。

• 延迟求值对于那些有副作用（Side Effect）和代价昂贵的代码来说是很有益处的，因为能控制代码什么时候执行。
• 闭包是一种函数，定义的时候是不执行，只有在调用的时候才执行，所有闭包有延迟求职功能。将表达式放在一个闭包之中，成为一个函数，当然就有了延迟求值功能
• 自动闭包是闭包中一种简略的表达形式，当然也有闭包的延迟求值功能

• 将闭包作为参数传递给函数时，能获得同样的延时求值行为。
• 自动闭包用@autoclosure标记，用在函数的参数中，一般不独立存在
• @autoclosure特性暗含了@noescape特性（同步）
• 如果想让这个闭包可以“逃逸”，则应该使@autoclosure(escaping)特性.（异步）

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// prints "5"

let customerProvider = { customersInLine.removeAtIndex(0) }
print(customersInLine.count)
// prints "5"

print("Now serving \(customerProvider())!")
// prints "Now serving Chris!"
print(customersInLine.count)
// prints "4"

// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serveCustomer(customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serveCustomer( { customersInLine.removeAtIndex(0) } )
// prints "Now serving Alex!"
print(customersInLine.count)
// prints "3"

// customersInLine is ["Ewa", "Barry", "Daniella"]
func serveCustomer(@autoclosure customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serveCustomer(customersInLine.removeAtIndex(0)) // 表达式自动转闭包，不用谢{}了
// prints "Now serving Ewa!"
print(customersInLine.count)
// prints "2"

// customersInLine is ["Barry", "Daniella"]
var customerProviders: [() -> String] = []
func collectCustomerProviders(@autoclosure(escaping) customerProvider: () -> String) {
    customerProviders.append(customerProvider)
}
collectCustomerProviders(customersInLine.removeAtIndex(0)) // 表达式自动转闭包，不用谢{}了
collectCustomerProviders(customersInLine.removeAtIndex(0)) // 表达式自动转闭包，不用谢{}了

print("Collected \(customerProviders.count) closures.")
// prints "Collected 2 closures."
for customerProvider in customerProviders {
    print("Now serving \(customerProvider())!")
}
// prints "Now serving Barry!"
// prints "Now serving Daniella!"

• 自动闭包是简单函数作为其他函数参数的一种方便写法
• 过度使用autoclosures会让你的代码变得难以理解。上下文和函数名应该能够清晰地表明求值是被延迟执行的。
• 为了省一对{}，引入@autoclosure关键字，有必要吗？实际使用中不如显示加上{}，表示这里是一个闭包，增加可读性
• @autoclosure特性暗含了@noescape特性（同步）；而普通闭包{}暗含了escape特性（异步）；这里刚好是相反的，理解上有困难吗？
• 函数调用的时候直接写表达式，并且可以省略{}，默认获得@noescape特性（同步），这大概就是自动闭包@autoclosure的好处吧。有必要吗？----用闭包{}，不用管同步还是异步，让系统处理，是否更好？