1、闭包（Closures）
闭包是独立的函数代码块，可以在代码中被传递和使用。Swift中的闭包与C语言和Objective-C语言中的block、其他语言中的lambda类似。
闭包可以从上下文中捕获和存储任意变量和常量的引用。这就是所谓的闭合并包裹这些变量和常量。Swift会处理捕获过程中的内存管理。
全局函数和嵌套函数实际上就是闭包的特殊情况。
闭包采取如下三种形式之一：
- 全局函数是一种有名字但不捕获任何值的闭包
- 嵌套函数是一种有名字并且能捕获封闭的函数作用域内的值的闭包。
- 闭包表达式是以轻量级语法写成的、没有名字的、并且能够捕获其上下文的值的闭包。
2、闭包表达式
闭包表达式拥有简洁的风格，在一般场景下可以进行语法优化。
Swift提供了一个sorted(isOrderedBefore:) 方法，其根据用于排序的闭包的返回值为数组的值进行排序。
例如，数组初始化如下：
1 let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
sorted(isOrderedBefore:)方法接收一个排序闭包作为参数，该闭包则接收数组的其中两个元素作为参数并返回一个Bool型的值来决定比较的两个元素哪一个排在前面。
因此，用于排序的闭包的函数类型是：(String, String) -> Bool
则用一般函数的形式写，则是：
1 func backward(_ s1: String, _ s2: String) -> Bool {
2 return s1 > s2
3 }
4 var reversed = names.sorted(isOrderedBefore: backward)
5 // reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
如果第一个字符串 (s1) 大于第二个字符串 (s2)，backward函数返回true，表示在新的数组中s1应该出现在s2前。
对于字符串中的字符来说，“大于” 表示 “按照字母顺序较晚出现”。 这意味着字母"B"大于字母"A"，字符串"Tom"大于字符串"Tim"。
这个函数将进行字母逆序排序，"Barry"将会排在"Alex"之前。
（1）表达式
用闭包表达式来写这个排序闭包，可以简化成：
1 reversedNames = names.sorted(isOrderedBefore: { (s1: String, s2: String) -> Bool in
2 return s1 > s2
3 })
下面是V2.1的对应方法：
1 reversed = names.sort({ (s1: String, s2: String) -> Bool in
2 return s1 > s2
3 })
闭包的类型为(String, String) -> Bool，闭包的函数体部分由in关键字引出。
由于上面的例子中，函数体部分较短，闭包可以写成：
1 reversedNames = names.sorted(isOrderedBefore: { (s1: String, s2: String) -> Bool in return s1 > s2 } )
（2）从上下文中推断类型
由于排序闭包是用来作为参数传递给sorted(isOrderedBefore:) 方法的，Swift就能根据上下文推断出闭包的参数类型和返回值类型。
sorted(isOrderedBefore:)方法被String数组调用，则闭包的类型一定是(String, String) -> Bool。则闭包中的参数类型和返回值类型可以忽略不写：
1 reversedNames = names.sorted(isOrderedBefore: { s1, s2 in return s1 > s2 } )
实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
（3）从单表达式隐式返回
单表达式的闭包可以忽略return关键字，隐式返回单行表达式的结果。
1 reversedNames = names.sorted(isOrderedBefore: { s1, s2 in s1 > s2 } )
（4）参数名称缩写
Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过$0,$1,$2来顺序调用闭包的参数。
如果在闭包表达式中使用参数名称缩写，可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。 in关键字也同样可以被省略：
1 reversed = names.sorted(isOrderedBefore: { $0 > $1 } )
其中，$0和$1分别对应第一个和第二个String参数
（5）运算符函数
Swift 的String类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值。 而这正好与sorted(isOrderedBefore:)需要的方法的第二个参数需要的函数类型相符合。 因此，可以简单地传递一个>，Swift可以自动推断出您想使用>的字符串函数实现：
1 reversed = names.sorted(isOrderedBefore: >)
3、尾随闭包（Trailing Closures）
如果需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
1 func someFunctionThatTakesAClosure(closure: () -> Void) {
2 // function body goes here
3 }
4
5 // here‘s how you call this function without using a trailing closure:
6
7 someFunctionThatTakesAClosure(closure: {
8 // closure‘s body goes here
9 })
10
11 // here‘s how you call this function with a trailing closure instead:
12
13 someFunctionThatTakesAClosure() {
14 // trailing closure‘s body goes here
15 }
用尾随闭包，可以将上面的排序闭包写成：
1 reversed = names.sorted() { $0 > $1 }
如果闭包表达式是函数或方法的唯一参数，则可以省略括号：
1 reversed = names.sorted { $0 > $1 }
当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。
例如，Swift 的数组有一个map方法，其获取一个闭包表达式作为其唯一参数。 对于数组中的每一个元素，调用一次这个闭包函数，就会返回与该元素所映射的值(可能是不同类型的值)。 具体的映射方式和返回值类型由闭包来指定。
当给数组的每个元素提供闭包函数后，map方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
下面的例子中，将用map(_:)方法将Int数组映射为String数组。
1 let digitNames = [ 2 0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four", 3 5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine" 4 ] 5 let numbers = [16, 58, 510]
现在，传递一个尾随闭包给numbers的map方法来创建对应的字符串版本数组：
1 let strings = numbers.map {
2 (number) -> String in
3 var number = number
4 var output = ""
5 while number > 0 {
6 output = digitNames[number % 10]! + output
7 number /= 10
8 }
9 return output
10 }
11 // strings is inferred to be of type [String]
12 // its value is ["OneSix", "FiveEight", "FiveOneZero"]
V2.1:
1 let strings = numbers.map {
2 (var number) -> String in
3 var output = ""
4 while number > 0 {
5 output = digitNames[number % 10]! + output
6 number /= 10
7 }
8 return output
9 }
10 // strings is inferred to be of type [String]
11 // its value is ["OneSix", "FiveEight", "FiveOneZero"]
map在数组中为每一个元素调用了闭包表达式。 不需要指定闭包的输入参数number的类型，因为可以通过要映射的数组类型进行推断。
闭包表达式在每次被调用的时候创建了一个字符串并返回。 其使用求余运算符 (number % 10) 计算最后一位数字并利用digitNames字典获取所映射的字符串。
注意：在字典中用下标取值时取出的是optional类型。由于这里可以保证number % 10是一个有效的下标，所以用了强制解绑(!)。
4、捕获值
闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
在Swift中，最简单的捕获值的闭包形式就是嵌套函数。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
下例为一个函数makeIncrementor，它包含了一个嵌套函数incrementor。 嵌套函数incrementor从上下文中捕获了两个值，runningTotal和amount。 之后makeIncrementor将incrementor作为闭包返回。 每次调用incrementor时，其会以amount作为增量增加runningTotal的值。
1 func makeIncrementer(forIncrement amount: Int) -> () -> Int {
2 var runningTotal = 0
3 func incrementer() -> Int {
4 runningTotal += amount
5 return runningTotal
6 }
7 return incrementer
8 }
makeIncrementer的返回类型是 () -> Int。
makeIncrementer函数定义了一个整型变量runningTotal(初始为0) 用来存储当前跑步总数。 该值通过incrementor返回。
makeIncrementor有一个Int类型的参数，其外部命名为forIncrement， 内部命名为amount，表示每次incrementor被调用时runningTotal将要增加的量。
incrementor函数用来执行实际的增加操作，单独来看这个函数：
1 func incrementer() -> Int {
2 runningTotal += amount
3 return runningTotal
4 }
incrementer函数并没有任何参数，但是在函数体内访问了runningTotal和amount变量。这是因为其捕获在包含它的函数体内已经存在的runningTotal和amount变量的引用(reference)。捕捉了变量引用,保证了runningTotal和amount变量在调用完makeIncrementer后不会消失,并且保证了在下一次执行incrementer函数时,runningTotal可以继续增加。
下面，来使用makeIncrementer：
1 let incrementByTen = makeIncrementer(forIncrement: 10)
定义了一个叫做incrementByTen的常量，该常量指向一个每次调用会加10的incrementor函数。 调用这个函数多次可以得到以下结果：
1 incrementByTen() 2 // returns a value of 10 3 incrementByTen() 4 // returns a value of 20 5 incrementByTen() 6 // returns a value of 30
创建了另一个incrementor，其会有一个属于自己的独立的runningTotal变量的引用：
1 let incrementBySeven = makeIncrementer(forIncrement: 7) 2 incrementBySeven() 3 // returns a value of 7
调用incrementByTen不会影响incrementBySeven中的runningTotal变量：
1 incrementByTen() 2 // returns a value of 40
注意：如果把闭包赋值给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获该实例，将创建一个在闭包和实例间的强引用环。 Swift 使用捕获列表来打破这种强引用环。
5、闭包是一种引用类型
如果将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
1 let alsoIncrementByTen = incrementByTen 2 alsoIncrementByTen() 3 // returns a value of 50
6、非逃逸闭包（Nonescaping Closures）
一个闭包被当做一个参数传递给一个函数，但这个闭包在函数返回后仍然被调用，这就叫做这个闭包逃离了这个函数。
在定义一个需要把闭包作为参数的函数时，可以在参数类型前加上@noescape标记，提示这个闭包不允许逃离函数（不能在函数返回后被调用）。
让闭包带着@noescape标记，可以让编译器在了解闭包的生命周期的情况下做更多的aggressive optimizations。
1 func someFunctionWithNonescapingClosure(closure: @noescape () -> Void) {
2 closure()
3 }
一种闭包可以逃离函数的方式是，在函数体外将闭包定义为一个变量。例如，很多开始异步操作的函数都接收一个闭包参数作为结束句柄（completion handler），函数在开始这个异步操作后就返回了，但是这个闭包是在异步操作结束之后才被调用，这种情况下，闭包就需要逃离函数（滞后调用）。
1 var completionHandlers: [() -> Void] = []
2 func someFunctionWithEscapingClosure(completionHandler: () -> Void) {
3 completionHandlers.append(completionHandler)
4 }
someFunctionWithEscapingClosure(_:)函数接收一个闭包参数，并把这个闭包加到了定义在函数体外的闭包数组中。如果你在这里用了@noescape标记，就会产生编译错误。
将闭包标记为@noescape，可以在闭包中直接引用到self：
1 class SomeClass {
2 var x = 10
3 func doSomething() {
4 someFunctionWithNonescapingClosure { x = 200 }
5 someFunctionWithEscapingClosure { self.x = 100 }
6 }
7 }
8 let instance = SomeClass()
9 instance.doSomething()
10 print(instance.x)
11 // Prints "200"
12 completionHandlers.first?()
13 print(instance.x)
14 // Prints "100"
7、自动闭包（Autoclosures）
自动闭包是一种自动创建的闭包，其用于绑定一个表达式并将其作为参数传递给函数。自动闭包并不接收任何参数，当它被调用时，它返回绑定在其内部的表达式的值。
通常会调用接收自动闭包的函数，很少去实现这种函数。
例如，assert(condition:message:file:line:)函数接收自动闭包作为condition和message参数。其中，只有在Debug情况下才考虑condition参数，而只有当condition等于false的时候，才执行message。
自动闭包可以允许你惰性求值，内部代码直到调用闭包才会执行。惰性求值可以让你控制何时执行，这在计算消耗很大的情况下非常有用。
1 var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
2 print(customersInLine.count)
3 // prints "5"
4
5 let customerProvider = { customersInLine.removeAtIndex(0) }
6 print(customersInLine.count)
7 // prints "5"
8
9 print("Now serving \(customerProvider())!")
10 // prints "Now serving Chris!"
11 print(customersInLine.count)
12 // prints "4"
直到闭包真正被调用，customersInLine的第一个元素才被移除。需要注意的是：customerProvider的类型不是String，而是（）->String。
传递一个闭包作为函数的参数，同样有惰性求值的效果：
1 // customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
2 func serve(customer customerProvider: () -> String) {
3 print("Now serving \(customerProvider())!")
4 }
5 serve(customer: { customersInLine.remove(at: 0) } )
6 // Prints "Now serving Alex!"
下面是另一版本的serve函数，通过@autoclosure，自动将传入的表达式转换成自动闭包。
1 // customersInLine is ["Ewa", "Barry", "Daniella"]
2 func serve(customer customerProvider: @autoclosure () -> String) {
3 print("Now serving \(customerProvider())!")
4 }
5 serve(customer: customersInLine.remove(at: 0))
6 // Prints "Now serving Ewa!"
@autoclosure属性隐含了@noescape属性，这意味着，这个闭包只能用在函数内部。如果想让闭包能够逃离当前的作用域，在函数返回后闭包还能被调用，则使用 @autoclosure(escaping)属性：
1 // customersInLine is ["Barry", "Daniella"]
2 var customerProviders: [() -> String] = []
3 func collectCustomerProviders(_ customerProvider: @autoclosure(escaping) () -> String) {
4 customerProviders.append(customerProvider)
5 }
6 collectCustomerProviders(customersInLine.remove(at: 0))
7 collectCustomerProviders(customersInLine.remove(at: 0))
8 print("Collected \(customerProviders.count) closures.")
9 // Prints "Collected 2 closures."
10 for customerProvider in customerProviders {
11 print("Now serving \(customerProvider())!")
12 }
13 // Prints "Now serving Barry!"
14 // Prints "Now serving Daniella!"
在上面的代码中，没有将闭包用作customer参数进行调用，而是将闭包添加到customerProviders数组，这个闭包数组是在函数外部声明的，这意味着，数组中的闭包可以在函数返回后执行。所以，customer参数的值也就可以逃离函数的作用域。