Swift4.2语言规范(九) 闭包

闭包表达式

嵌套函数（在嵌套函数中引入）是一种方便的方法，可以将自包含的代码块命名和定义为更大函数的一部分。但是，在没有完整声明和名称的情况下编写类似函数的构造的更短版本有时是有用的。当您使用将函数作为其一个或多个参数的函数或方法时，尤其如此。

Closure表达式是一种以简短，集中的语法编写内联闭包的方法。Closure表达式提供了几种语法优化，用于以缩短的形式编写闭包，而不会丢失清晰度或意图。下面的闭包表达式示例通过sorted(by:)在几次迭代中细化方法的单个示例来说明这些优化，每次迭代都以更简洁的方式表达相同的功能。

let names = ["Chris","Alex","Ewa","Barry","Daniella"]

1 func backward(_ s1: String,_ s2: String) -> Bool {
2     return s1 > s2
3 }
4 var reversedNames = names.sorted(by: backward)
5 // reversedNames is equal to ["Ewa","Daniella","Chris","Barry","Alex"]

1 { (parameters) -> return type in
2     statements
3 }

1 reversedNames = names.sorted(by: { (s1: String,s2: String) -> Bool in
2     return s1 > s2
3 })

reversedNames = names.sorted(by: { (s1: String,s2: String) -> Bool in return s1 > s2 } )

reversedNames = names.sorted(by: { s1,s2 in return s1 > s2 } )

reversedNames = names.sorted(by: { s1,s2 in s1 > s2 } )

reversedNames = names.sorted(by: { $0 > $1 } )

reversedNames = names.sorted(by: { $0 > $1 } )

尾随闭包

如果需要将闭包表达式作为函数的最终参数传递给函数，并且闭包表达式很长，则将其写为尾随闭包可能很有用。在函数调用的括号之后写入尾随闭包，即使它仍然是函数的参数。使用尾随闭包语法时，不要将闭包的参数标签写为函数调用的一部分。

 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 }

上面的Closure Expression Syntax部分的字符串排序闭包可以sorted(by:)作为尾随闭包写在方法的括号之外：

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

如果提供闭包表达式作为函数或方法的唯一参数，并且您将该表达式作为尾随闭包提供，则()在调用函数时，不需要在函数或方法的名称后面写一对括号：

reversedNames = names.sorted { $0 > $1 }

当闭包足够长以至于无法将其内联写入单行时，尾随闭包最有用。作为一个例子，Swift的Array类型有一个map(_:)方法，它将一个闭包表达式作为它的单个参数。对数组中的每个项调用一次闭包，并为该项返回一个替代映射值（可能是某些其他类型）。映射的性质和返回值的类型留给要指定的闭包。

将提供的闭包应用于每个数组元素后，该map(_:)方法返回一个包含所有新映射值的新数组，其顺序与原始数组中的相应值相同。

以下是如何使用map(_:)带尾随闭包的方法将Int值数组转换为值数组String。该数组用于创建新数组：[16,?58,?510]["OneSix",?"FiveEight",?"FiveOneZero"]

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数组来创建String值数组map(_:)：

 1 let strings = numbers.map { (number) -> String in
 2     var number = number
 3     var output = ""
 4     repeat {
 5         output = digitNames[number % 10]! + output
 6         number /= 10
 7     } while number > 0
 8     return output
 9 }
10 // strings is inferred to be of type [String]
11 // its value is ["OneSix","FiveEight","FiveOneZero"]

该map(_:)方法为数组中的每个项调用一次闭包表达式。您不需要指定闭包的输入参数number的类型，因为可以从要映射的数组中的值推断出类型。

在此示例中，number使用closure的number参数值初始化变量，以便可以在闭包体内修改该值。（函数和闭包的参数总是常量。）闭包表达式还指定了返回类型String，以指示将存储在映射的输出数组中的类型。

闭包表达式构建一个output每次调用时都调用的字符串。它number使用余数运算符（）计算最后一位数字，并使用该数字在字典中查找适当的字符串。闭包可用于创建大于零的任何整数的字符串表示。number?%?10digitNames

从检索到的字符串digitNames辞典被添加到前面的output，有效地建立反向一数目的字符串版本。（该表达式给出for?，for?和for的值。）number?%?106168580510

number然后将变量除以10。因为它是一个整数，所以它在分割期间向下舍入，因此16变为1，58变为5，510变为51。

重复该过程直到number等于0，此时output字符串由闭包返回，并通过该map(_:)方法添加到输出数组。

在上面的示例中使用尾随闭包语法在闭包支持的函数之后立即巧妙地封装了闭包的功能，而无需在map(_:)方法的外括号内包装整个闭包。

捕捉常量和变量

闭包可以从定义它的周围上下文中捕获常量和变量。然后闭包可以引用并修改其体内的常量和变量的值，即使定义常量和变量的原始范围不再存在。

在Swift中，可以捕获值的最简单形式的闭包是嵌套函数，写在另一个函数体内。嵌套函数可以捕获其外部函数的任何参数，还可以捕获外部函数中定义的任何常量和变量。

这是一个调用函数的示例makeIncrementer，其中包含一个名为的嵌套函数incrementer。嵌套incrementer()函数捕获两个值，runningTotal并且amount，从它的周围环境。捕获这些值后，incrementer将makeIncrementer作为一个闭包返回runningTotal，amount每次调用时它都会递增。

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是。这意味着它返回一个函数，而不是一个简单的值。它返回的函数没有参数，每次调用时都返回一个值。要了解函数如何返回其他函数，请参见函数类型作为返回类型。()?->?IntInt

该makeIncrementer(forIncrement:)函数定义了一个名为的整数变量runningTotal，用于存储将返回的增量器的当前运行总数。此变量初始化为值0。

该makeIncrementer(forIncrement:)函数有一个Int参数标签为forIncrement的参数，参数名称为amount。传递给此参数的参数值指定runningTotal每次调用返回的增量函数时应递增多少。该makeIncrementer函数定义了一个名为的嵌套函数incrementer，它执行实际的递增。此功能只是增加了amount对runningTotal，并返回结果。

在单独考虑时，嵌套incrementer()函数可能看起来不常见：

1 func incrementer() -> Int {
2     runningTotal += amount
3     return runningTotal
4 }

该incrementer()函数没有任何参数，但它在其函数体中引用runningTotal和引用amount。它通过捕获做到这一点参考，以runningTotal和amount从周围的功能和其自身的函数体中使用它们。通过参考捕捉保证runningTotal和amount不消失的时候调用makeIncrementer结束，而且也保证了runningTotal可用下一次incrementer函数被调用。

这是一个实际的例子makeIncrementer：

let incrementByTen = makeIncrementer(forIncrement: 10)

此示例设置一个常量incrementByTen，该常量称为引用增量函数，10该函数在runningTotal每次调用时都会添加到其变量中。多次调用该函数会显示此行为：

1 incrementByTen()
2 // returns a value of 10
3 incrementByTen()
4 // returns a value of 20
5 incrementByTen()
6 // returns a value of 30

如果您创建第二个增量器，它将拥有自己存储的对新的单独runningTotal变量的引用：

1 let incrementBySeven = makeIncrementer(forIncrement: 7)
2 incrementBySeven()
3 // returns a value of 7

incrementByTen再次调用原始增量器（）会继续增加其自己的runningTotal变量，并且不会影响由incrementBySeven以下内容捕获的变量：

1 incrementByTen()
2 // returns a value of 40

闭包是引用类型

在上面的例子中，incrementBySeven并且incrementByTen是常量，但这些常量引用的闭包仍然能够增加runningTotal它们捕获的变量。这是因为函数和闭包是引用类型。

无论何时将函数或闭包赋值给常量或变量，实际上都是将该常量或变量设置为对函数或闭包的引用。在上面的例子中，闭包的选择incrementByTen?引用的是常量，而不是闭包本身的内容。

这也意味着如果为两个不同的常量或变量分配闭包，那么这两个常量或变量都引用相同的闭包。

1 let alsoIncrementByTen = incrementByTen
2 alsoIncrementByTen()
3 // returns a value of 50
4 
5 incrementByTen()
6 // returns a value of 60

上面的例子显示调用alsoIncrementByTen与调用相同incrementByTen。因为它们都引用相同的闭包，它们都会递增并返回相同的运行总计。

离开闭包

离开闭包是说离开当闭包作为参数传递给函数，但在函数返回之后被调用的函数。当声明一个以闭包作为其参数之一的函数时，可以@escaping在参数的类型之前写入，以指示允许闭包转义。

闭包可以转义的一种方法是存储在函数外部定义的变量中。作为示例，许多启动异步操作的函数将闭包参数作为完成处理程序。该函数在开始操作后返回，但是在操作完成之前不会调用闭包 - 闭包需要转义，以便稍后调用。例如：

1 var completionHandlers: [() -> Void] = []
2 func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
3     completionHandlers.append(completionHandler)
4 }

该someFunctionWithEscapingClosure(_:)函数将闭包作为其参数，并将其添加到在函数外部声明的数组中。如果没有用此标记此函数的参数@escaping，则会出现编译时错误。

标记闭包@escaping意味着必须self在闭包中明确引用。例如，在下面的代码中，传递给的闭包someFunctionWithEscapingClosure(_:)是一个转义闭包，这意味着它需要self显式引用。相反，传递给的闭包someFunctionWithNonescapingClosure(_:)是一个非自动闭包，这意味着它可以self隐含地引用。

 1 func someFunctionWithNonescapingClosure(closure: () -> Void) {
 2     closure()
 3 }
 4 
 5 class SomeClass {
 6     var x = 10
 7     func doSomething() {
 8         someFunctionWithEscapingClosure { self.x = 100 }
 9         someFunctionWithNonescapingClosure { x = 200 }
10     }
11 }
12 
13 let instance = SomeClass()
14 instance.doSomething()
15 print(instance.x)
16 // Prints "200"
17 
18 completionHandlers.first?()
19 print(instance.x)
20 // Prints "100"

自动闭包

一个autoclosure是自动创建来包装被真实作为参数传递给函数的表达式的闭包。它不接受任何参数，当它被调用时，它返回包含在其中的表达式的值。这种语法方便性允许您通过编写普通表达式而不是显式闭包来省略函数参数周围的大括号。

这是常见的来电称取autoclosures的功能，但它不是常见的实现那种功能。例如，该assert(condition:message:file:line:)函数为其condition和message参数采用autoclosure?;?它condition仅在调试参数进行评估，并建立其message仅在参数评估condition是false。

autoclosure允许您延迟评估，因为在您调用闭包之前，内部代码不会运行。延迟评估对于具有副作用或计算成本高昂的代码非常有用，因为它可以让您控制何时评估该代码。下面的代码显示了闭包延迟评估的方式。

 1 var customersInLine = ["Chris","Daniella"]
 2 print(customersInLine.count)
 3 // Prints "5"
 4 
 5 let customerProvider = { customersInLine.remove(at: 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，但不带任何参数，返回一个字符串-a功能。()?->?String

当您将闭包作为参数传递给函数时，您会得到相同的延迟求值行为。

1 // customersInLine is ["Alex","Ewa","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(customer:)上面列表中的函数采用显式闭包，返回客户的名称。下面的版本serve(customer:)执行相同的操作，但不是采用显式闭包，而是通过使用@autoclosure属性标记其参数的类型来进行自动闭包。现在，您可以调用该函数，就好像它使用了一个String参数而不是一个闭包。参数自动转换为闭包，因为customerProvider参数的类型用@autoclosure属性标记。

1 // customersInLine is ["Ewa","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，请使用@autoclosure和@escaping属性。@escaping上面在Escaping Closures中描述了该属性。

 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 
 9 print("Collected (customerProviders.count) closures.")
10 // Prints "Collected 2 closures."
11 for customerProvider in customerProviders {
12     print("Now serving (customerProvider())!")
13 }
14 // Prints "Now serving Barry!"
15 // Prints "Now serving Daniella!"

在上面的代码中，函数将闭包附加到数组，而不是调用作为customerProvider参数传递给它collectCustomerProviders(_:)的闭包customerProviders。数组声明在函数范围之外，这意味着数组中的闭包可以在函数返回后执行。因此，customerProvider必须允许参数的值转义函数的作用域。