Swift教程之闭包

闭包

Swift的闭包类型类似于C和Objective-C中的块以及其他编程语言的Lambdas。

闭包可捕获并存储其定义的上下文中的任何常量和变量的引用，称为捕获常量和变量。

全局函数和嵌套函数实际上是闭包的特殊情况，闭包有三种形式：

• 全局函数是具有函数名且不捕获值的闭包。
• 嵌套函数是具有函数名且捕获函数体内的值的闭包。
• 闭包表达式是轻量级的未命名闭包，且从其上下文中捕获值。

Swift的闭包表达式经过优化后鼓励使用简单、整洁的语法，包括：

• 从上下文推倒参数和返回值类型
• 单个闭包表达式的隐式返回
• 参数名称简写
• 尾随闭包语法

闭包表达式

闭包表达式是一种以简短语法编写内联闭包的方法。下面的闭包表达式示例通过闭包表达式说明这些语法优化。

排序方法

sorted(by:)方法根据传入的排序闭包的输出对已知类型的数组进行排序，并返回已排序好的新数组，原数组未被修改。

sorted(by:)方法接收一个闭包，该闭包接收与数组元素相同类型的两个参数，并返回Bool值，表示前值应该在后值之前(返回true)或之后(返回false)出现。

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

然后，这是一个相当长的方式来编写本质上是单表达式函数(a > b)，可使用闭包表达式语法来编写排序闭包。

闭包表达式语法

闭包表达式语法有以下形式：

{ (parameters) -> return type in

    statements

}

闭包表达式语法中的参数可以是in-out参数和可变参数，但不能有默认值。元组可用作参数类型和返回类型。

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

可将闭包表达式写在单行：

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

从上下文推导类型

由于排序闭包作为参数传递给方法，Swift可推断其参数的类型和返回值的类型。因为可以推断所有的类型，所以返回箭头和参数名周围括号也可省略。

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

单表达式闭包的隐式返回

单表达式闭包可省略return关键字来隐式返回单个表达式的结果：

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

参数名简写

Swift自动为内联闭包提供简写参数名称，可通过名称$0、$1、$2等引用闭包参数值。

若闭包表达式使用简写参数名称，则可以从定义中省略闭包的参数列表，并根据预期函数类型推断简写参数名称的数量和类型，in关键字也可省略，因为闭包表达式完全由其主体组成：

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

这里的$0和$1表示闭包的第一个和第二个String参数。

运算符方法

还有更加简短的方式书写上述闭包表达式。Swift的操作符本质上就是函数，可以简单地传入运算符作为闭包表达式：

reversedNames = names.sorted(by: >)

尾随闭包

当需要传入一个较长的闭包表达式作为函数的最后一个参数时，那这个闭包表达式就是尾随闭包。使用尾随闭包语法时，不要将闭包的参数标签写入函数调用的一部分。

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}
 
// Here's how you call this function without using a trailing closure:
 
someFunctionThatTakesAClosure(closure: {
    // closure's body goes here
})
 
// Here's how you call this function with a trailing closure instead:
 
someFunctionThatTakesAClosure() {
    // trailing closure's body goes here
}

可以将sorted(by:)方法的字符串排序闭包写成尾随闭包：

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

当闭包表达式是函数的唯一参数时，且该表达式为尾随闭包，那么在调用该函数时不需要在函数名后写一对圆括号()。

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

Array类型的map(_:)方法将闭包作为唯一参数，其作用是返回一个按照闭包的映射规则映射所有元素的新数组。将该闭包表达式写成尾随闭包：

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 = ""
    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0
    return output
}
// strings is inferred to be of type [String]
// its value is ["OneSix", "FiveEight", "FiveOneZero"]

捕获值

闭包能从定义的上下文捕获常量和变量，即使定义常量和变量的原始范围不再存在，闭包也可以引用病修改这些值。

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

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

上述嵌套函数incrementer捕获了外部函数makeIncrementer的参数amount和外部函数定义的runningTotal变量。

将incrementer函数保存为常量或变量，函数内对runningTotal和amount的引用依然存在：

let incrementByTen = makeIncrementer(forIncrement: 10)   
incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30

创建另一个incrementer函数，捕获值的引用也随之初始化：

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

调用原来的incrementByTen函数会继续引用自己的runningTotal变量，且不会影响到incrementBySeven函数捕获到的变量：

incrementByTen()
// returns a value of 40

闭包是引用类型

函数和闭包都是引用类型，无论何时为常量或变量分配函数或闭包，就将该常量或变量设置为对函数或闭包的引用。若将闭包分配给两个不同的常量或变量，这些常量或变量都将使用相同的闭包：

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// returns a value of 50

逃逸闭包

非逃逸闭包的生命周期：

1. 把闭包作为参数传递给函数。
2. 函数中运行该闭包。
3. 退出函数。

非逃逸闭包的引用计数和退出函数时保持不变。

逃逸闭包与非逃逸闭包相反，当函数退出时，逃逸闭包的引用仍然被其他对象持有，不会在持有函数结束后释放。

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

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}
 
class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}
 
let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"
 
completionHandlers.first?()
print(instance.x)
// Prints "100"

使用逃逸闭包的两个场景：

• 异步调用：如果需要调度队列中异步调用闭包， 这个队列会持有闭包的引用，至于什么时候调用闭包，或闭包什么时候运行结束都是不可预知的。
• 需要存储闭包作为属性，全局变量或其他类型做稍后使用。

自动闭包

自动闭包是一个自动创建的闭包，用于包装一个作为参数传递给函数的表达式。它没有任何参数，当被调用时，它返回包含在其中的表达式的值。

自动闭包让代码延迟之行，在调用闭包之前，内部代码不会运行。延迟之行对具有副作用或计算上昂贵的代码很有用，可以控制何时执行该代码：

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// Prints "5"
 
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// Prints "5"
 
print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// Prints "4"

即使customersInLine数组的第一个元素被封装内部的代码删除，数组元素在世纪调用闭包之前不会被删除。customerProvider的类型不是String，而是 () -> String ：一个返回字符串没有参数的函数。

当将闭包作为函数传递给函数时，依然会延迟执行：

// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } )
// Prints "Now serving Alex!"

// customersInLine is ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
// Prints "Now serving Ewa!"

注意

过度使用自动闭包会使代码难以理解，应通过上下文和函数名称说明正在使用延迟执行。

同时使用逃逸闭包和自动闭包：

// customersInLine is ["Barry", "Daniella"]
var customerProviders: [() -> String] = []
func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
    customerProviders.append(customerProvider)
}
collectCustomerProviders(customersInLine.remove(at: 0))
collectCustomerProviders(customersInLine.remove(at: 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!"