闭包是自包含的函数代码块,可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C 中的代码块(blocks)以及其他一些编程语言中的匿名函数比较相似。
闭包可以捕获和存储其所在上下文中任意常量和变量的引用。被称为包裹常量和变量。Swift 会为你管理在捕获过程中涉及到的所有内存操作。
在函数章节中介绍的全局和嵌套函数实际上也是特殊的闭包,闭包采取如下三种形式之一:
全局函数是一个有名字但不会捕获任何值的闭包;
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包;
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包。
Swift 的闭包表达式拥有简洁的风格,并鼓励在常见场景中进行语法优化,主要优化如下:
利用上下文推断参数和返回值类型;
隐式返回单表达式闭包,即单表达式闭包可以省略 return 关键字;
参数名称缩写;
尾随闭包语法。
闭包表达式
闭包表达式是一种利用简洁语法构建内联闭包的方式。在保证不丢失它语法清晰明了的同时,闭包表达式提供了几种优化的语法简写形式。下面通过对 sorted(by:) 这一个案例的多次迭代改进来展示这个过程,每次迭代都使用了更加简明的方式描述了相同功能。
排序方法
Swift 标准库提供了名为 sorted(by:) 的方法,它会根据你所提供的用于排序的闭包函数将已知类型数组中的值进行排序。一旦排序完成,sorted(by:) 方法会返回一个与原数组大小相同、包含同类型元素且元素已正确排序的新数组,原数组不会被 sorted(by:) 方法修改。
下面的闭包表达式示例使用 sorted(by:) 方法对一个 String 类型的数组进行字母逆序排序。以下是初始数组:
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
sorted(by:) 方法接受一个闭包,该闭包函数需要传入与数组元素类型相同的两个值,并返回一个布尔类型的值来表明当前排序结束后传入的第一个参数排在第二个参数的前面还是后面,如果第一个参数值出现在第二个参数值的前面,排序闭包函数需要返回 true,反之返回 false。
提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数,并将其作为 sorted(by:) 方法的参数传入:
func backward(_ s1: String, _ s2: String) -> Bool {
return s1 > s2
}
提供的闭包函数将作为参数传入 sorted(by:) 方法中
var reversedNames = names.sorted(by: backward(_:_:))
// reversedNames 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
如果第一个字符串 s1 大于第二个字符串 s2,backward(_: _: ) 函数会返回 true,表示在新的数组中 s1 应该出现在 s2前面,也就是说该闭包将进行字母逆序排序。
然而,以这种方式来编写一个实际上很简单的表达式(a > b),确实太过繁琐了。对于这个例子来说,利用闭包表达式语法可以更好地构造一个内联排序闭包。
闭包表达式语法
闭包表达式语法有如下的一般形式:
{ (parameter) -> returnType in
statements
}
闭包表达式参数可以是 in-out 参数,但不能设定默认值。也可以使用具名的可变参数(可变参数必须放在参数列表的最后一位)。元组也可以作为参数和返回值。下面的例子展示了前边 backward(_: _: ) 函数对应的闭包表达式版本的代码:
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
return s1 > s2
})
需要注意的是内联闭包参数和返回值类型声明与 backward(_: _: ) 函数类型声明相同。在这两种方式中,都写成了 (s1: String, s2: String) -> Bool。然而在内联闭包表达式中,函数和返回值类型都写在大括号内,而不是大括号外。
闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成,闭包函数体即将开始。
该例中 sorted(by:) 方法的整体调用保持不变,一对圆括号仍然包裹住了方法的整个参数。然而,参数现在变成了内联闭包。
根据上下文推断类型
因为排序闭包函数是作为 sorted(by:) 方法的参数传入的,Swift 可以推断其参数和返回值的类型。sorted(by:) 方法被一个字符串数组调用,因此其参数必须是 (String, String) -> Bool 类型的函数。这意味着 (String, String) 和 Bool 类型并不需要作为闭包表达式定义的一部分。因为所有的类型都可以被正确推断,返回箭头(->)和围绕在参数周围的括号也可以被省略:
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 的 String 类型定义了关于大于号( > )的字符串实现,其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值,而这正好与 sorted(by:) 方法的参数需要的函数类型相符合。因此,可以简单地传递一个大于号,Swift 可以自动推断出你想使用大于号的字符串函数实现的排序。
reversedNames = names.sorted(by: >)
尾随闭包
如果需要将一个很长的闭包表达式作为最后一个参数传递给函数,可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式,函数支持将其作为最后一个参数调用。在使用尾随闭包时,不用写出它的参数标签。
func someFunctionThatTakesAClosure(closure: () -> Void) {
// 函数体部分
}
// 以下是 不 使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
// 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
// 闭包主体部分
}
在闭包表达式语法一节中作为 sorted(by:) 方法参数的字符串排序闭包可以写成:
reversedNames = names.sorted() {$0 > $1}
如果闭包表达式是函数或方法的唯一参数,则使用尾随闭包时,甚至可以把 () 省略掉:
reversedNames = names.sorted {$0 > $1}
闭包非常长以至于不能在一行中进行书写时,尾随闭包变得非常有用。例如,Swift 的 Array 类型有一个 map(_: ) 方法,这个方法获取一个闭包表达式作为其唯一参数。该闭包函数会为数组中的每一个元素调用一次,并返回该元素所映射的值。具体的映射方法和返回值类型由闭包来指定。
当提供给数组的闭包应用于每个数组元素后,map(_: ) 方法将返回一个新数组,新数组中包含了与原数组中的元素一一对应的映射后的值。
下例介绍如何在 map(_: ) 方法使用尾随闭包将 Int 类型数组 [16, 58, 510] 转换为包含对应 String 类型的值的数组 [“OneSix”, “FiveEight”, “FiveOneZero”]:
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 常量被推断为字符串类型数组,即 [String],其值为 ["OneSix", "FiveEight", "FiveOneZero"]
map( _: ) 为数组中每一个元素调用了一次闭包表达式。你不需要指定闭包的输入参数 number 的类型,因为可以通过要映射的数组进行推断。上述例子中,通过尾随闭包语法,优雅地在函数后封装了闭包的具体功能,而不再需要将整个闭包包裹在 map( _: ) 方法的括号内。
注意:
字典 digitNames 下标后跟着一个叹号(!),因为字典下标返回一个可选值(optional value),表明该键不存在时会查找失败。在上例中,由于可以确定 number % 10 总是 digitNames 字典的有效下标,因此叹号可以用于强制解包(force-unwrap)存储在下标的可选类型的返回值中的 String 类型的值。
值捕获
闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在,闭包仍然可以在闭包函数体内引用和修改这些值。Swift 中,可以捕获值的闭包的最简单形式是嵌套函数,也就是定义在其他函数的函数体内的函数。嵌套函数能捕获其外部函数所有的参数及定义的常量和变量。
举个例子,这有一个叫做 makeIncrementer 的函数,其包含了一个叫做 incrementer 的嵌套函数。嵌套函数 incrementer() 从上下文中捕获了两个值,runningTotal 和 amount。捕获这些值之后,makeIncrementer 将 incrementer 作为闭包返回。每次调用 incrementer 时,其会以 amount 作为增量增加 runningTotal 的值。
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
makeIncrementer 返回类型为 () -> Int。这意味着其返回的是一个函数,而非一个简单类型的值。
incrementer() 函数并没有任何参数,但是在函数体内访问了 runningTotal 和 amount 变量。这是因为它从外围函数捕获了 runningTotal 和 amount 变量的引用。捕获引用保证了 runningTotal 和 amount 变量在调用完 makeIncrementer 后不会消失,并且保证了在下一次执行 incrementer 函数时,runningTotal 依旧存在。
下面是一个使用 makeIncrementer 的例子:
let incrementByTen = makeIncrementer(forIncrement: 10)
print(incrementByTen()) // 打印10
print(incrementByTen()) // 打印20
print(incrementByTen()) // 打印30
如果创建了另一个 incrementer,它会有属于自己的引用,指向一个全新、独立的 runningTotal 变量:
let incrementBySeven = makeIncrementer(forIncrement: 7)
print(incrementBySeven()) // 打印7
print(incrementBySeven()) // 打印14
再次调用原来的 incrementByTen 会继续增加它自己的 runningTotal 变量,该变量和 incrementBySeven 中捕获的变量没有任何联系:
print(incrementByTen()) // 打印40
注意:
如果你将闭包赋值给一个类实例的属性,并且该闭包通过访问该实例或其成员而捕获了该实例,你将在闭包和该实例间创建一个循环强引用。Swift 使用捕获列表来打破这种循环强引用。(后续章节会详细介绍)
闭包是引用类型
上面的例子中,incrementBySeven 和 incrementByTen 都是常量,但是这些常量指向的闭包仍然可以增加其捕获的变量的值。这是因为函数和闭包都是引用类型。
无论你将函数或闭包赋值给一个常量还是变量,你实际上都是将常量或变量的值设置为对应函数或闭包的引用。上面的例子中,指向闭包的引用 incrementByTen 是一个常量,而并非闭包内容本身。
这也意味着如果你将闭包赋值给了两个不同的常量或变量,两个值都会指向同一个闭包。
let alsoIncrementByTen = incrementByTen
print(alsoIncrementByTen()) // 打印50
逃逸闭包
当一个闭包作为参数传到一个函数中,但是这个闭包在函数返回之后才被执行,我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时,你可以在参数名之前标注 @escaping,用来指明这个闭包是允许“逃逸”出这个函数的。
一种能使闭包“逃逸”出函数的方法是,将这个闭包保存在一个函数外部定义的变量中。
举个例子,很多启动异步操作的函数接受一个闭包参数作为 completion handler。这类函数会在异步操作开始之后立刻返回,但是闭包直到异步操作结束后才会被调用。在这种情况下,闭包需要“逃逸”出函数,因为闭包需要在函数返回之后被调用。
例如:
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
someFunctionWithEscapingClosure(_: ) 函数接受一个闭包作为参数,该闭包被添加到一个函数外定义的数组中。如果你不将这个参数标记为 @escaping,就会得到一个编译错误。
将一个闭包标记为 @escaping 意味着你必须在闭包中显式地引用 self。
比如说,在下面的代码中,传递到 someFunctionWithEscapingClosure( _: ) 中的闭包是一个逃逸闭包,这意味着它需要显式地引用 self。相对的,传递到 someFunctionWithNonescapingClosure( _: ) 中的闭包是一个非逃逸闭包,这意味着它可以隐式引用 self。
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) // 打印出 200
completionHandlers.first?()
print(instance.x) // 打印出 100
自动闭包
自动闭包是一种自动创建的闭包,用于包装传递给函数作为参数的表达式。这种闭包不接受任何参数,当它被调用的时候,会返回被包装在其中的表达式的值。这种便利语法让你能够省略闭包的花括号,用一个普通的表达式来代替显示的闭包。
自动闭包让你能够延迟求值,因为直到你调用这个闭包,代码段才会被执行。
下面的代码展示了闭包如何延时求值:
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count) // 打印出 5
let customerProvider = {customersInLine.remove(at: 0)}
print(customersInLine.count) // 打印 5
print("Now serving \(customerProvider())!") // 打印 Now serving Chris!
print(customersInLine.count) // 打印 4
尽管在闭包的代码中,customersInLine 的第一个元素被移除了,不过在闭包被调用之前,这个元素是不会被移除的。如果这个闭包永远不被调用,那么在闭包里面的表达式将永远不会执行,那意味着列表中的元素永远不会被移除。请注意,customerProvider 的类型不是 String,而是 () -> String,一个没有参数且返回值为 String 的函数。
将闭包作为参数传递给函数时,同样可以获得延时求值行为。
// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
print("Now serving \(customerProvider())!")
}
serve(customer: {customersInLine.remove(at: 0)}) // 打印 Now serving Alex!
上面的 serve(customer:) 函数接受一个返回顾客名字的显式的闭包。
下面这个版本的 serve(customer:) 完成了相同的操作,不过它并没有接受一个显式的闭包,而是通过将参数标记为 @autoclosure 来接收一个自动闭包。现在你可以将该函数当作接受 String 类型参数(而非闭包)的函数来调用。 customerProvider 参数将自动转化为一个闭包,因为该参数被标记了 @autoclosure 特性。
// customersInLine is ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0)) // 打印 Now serving Ewa!
注意:
上面的serve(customer:) 函数在调用时,会提示传入一个 String 类型的参数( serve(customer: String) ),这种提示可能会混淆代码意图(其实是传入一个闭包)。所以过度使用 autoclosures 会让你的代码变得难以理解。上下文和函数名应该能够清晰地表明求值是被延迟执行的。
如果你想让一个自动闭包可以“逃逸”,则应该同时使用 @autoclosure 和 @escaping 属性。
// customersInLine i = ["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.") // 打印 "Collected 2 closures."
for customerProvider in customerProviders {
print("Now serving \(customerProvider())!")
}
// 打印 "Now serving Barry!"
// 打印 "Now serving Daniella!"
在上面的代码中,collectCustomerProviders(_: ) 函数并没有调用传入的 customerProvider 闭包,而是将闭包追加到了 customerProviders 数组中。这个数组定义在函数作用域范围外,这意味着数组内的闭包能够在函数返回之后被调用。因此,customerProvider 参数必须允许“逃逸”出函数作用域。