Swift中的闭包总结

闭包是自包含的函数代码块，Swift 中的闭包与 C 和 Objective-C 中的代码块(b
locks)以及其他一些编程语言中的匿名函数比较相似。Swift 会为你管理在捕获过程中涉及到的所有内存操作。

闭包表达式的语法：

1
2
3

{ (parameters) -> returnType in
    statements
}

闭包表达式参数可以是 in-out 参数，但不能设定默认值。也可以使用具名的可变参数。闭包的函数体部分由关键字 in 引入，表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。

举个例子，sorted(by:)方法接收一个闭包，接收两个参数，返回一个 Bool 值：

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

let reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
  return s1 > s2
})
// reversedNames 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

上面的闭包函数体也可以改写成一行代码，一对圆括号仍然包裹住了方法的整个参数。然而，参数现在变成了内联闭包。：

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

由于 Swift 可以推断其参数和返回值类型，所以其参数(String, String) -> Bool类型的函数并不需要作为闭包表达式定义的一部分。因为所有类型都可以被推断，所以->和围绕在参数周围的括号也可以被省略：

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

单表达式闭包(这里闭包函数体只包含了一个单一表达式( s1 > s2 ))可以通过省略return关键字来隐式返回单行表达式的结果：

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

Swift 为内联闭包提供参数名称缩写功能，你可以通过$0，$1，$2来顺序调用闭包的参数，以此类推。如果闭包表达式中使用参数名称缩写，也可以在闭包定义中省略参数列表，并且对应参数名称缩写的类型会通过函数类型进行推断。in 关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成（$0、$1分别表示闭包的第一个和第二个参数）。

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

运算符方法：String类型定义了关于>的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型。这恰好与sorted(by:)方法的参数需要函数类型相符合。所以可以自动推断出>的字符串函数实现。

1	reversedNames = names.sorted(by: >)

尾随闭包

如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签：

func someFunctionThatTakesAClosure(closure: () -> Void) {
  // 函数体部分
}
// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
  // 闭包主体部分
})
// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
  // 闭包主体部分
}

上面的例子可改写为：

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

如果闭包表达式是函数或方法的唯一参数，可以省略（）：

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

值捕获

闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

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

// 无论你是将函数或闭包赋值给一个常量还是变量，实际上都是将常量或者变量的值设置为对应行数或者闭包的引用
let incrementByTen = makeIncrementor(forIncrement: 10)

闭包捕获了amount、runningTotal两个变量的引用，捕获引用保证了 runningTotal 和 amount 变量在调用完 makeIncrementer 后不会消失，并且保证了在下一次执行 incrementer 函数时，runningTotal 依旧存在。Swift 负责被捕获变量的所有内存管理工作，包括释放不再需要的变量。

1 2	incrementByTen() // 10 incrementByTen() // 20

注意：如果你将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，你将在闭包和该实例间创建一个循环强引用

逃逸闭包

逃逸闭包：当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。可以在参数名之前标注@escaping，来指明这个闭包时允许“逃逸”出这个函数的。

一种能使闭包“逃逸”出函数的方法是，将这个闭包保存在一个函数外部定义的变量中。比如常用的回调函数，这类函数会在异步操作开始之后立刻返回，但是闭包直到异步操作结束后才会被调用。在这种情况下，闭包需要“逃逸”出函数，因为闭包需要在函数返回之后被调用。例如：

// someFunctionWithEscapingClosure(_:)中的闭包是一个逃逸闭包，该闭包被添加到一个函数外定义的数组中。如果不显示将参数标记为 @escaping ，会得到编译错误
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
  completionHandlers.append(completionHandler)
}

注意：标记为@escaping的闭包必须在闭包中显式的引用self，而非逃逸闭包，它可以隐式的引用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

// customerProvider 的类型不是 String，而是 () -> String
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count) // 5

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

将闭包作为参数传递给函数时，同样能获取延时求值行为。

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

print(customersInLine) // ["Ewa", "Barry", "Daniella"]

也可以将参数标记为 @autoclosure 来接收一个自动闭包。现在可以将该函数当做接受String类型参数（而非闭包）的函数来调用。customerProvider参数将自动转化为一个闭包，因为该参数被标记了@autoclosure特性。

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

如果想让一个闭包自动“逃逸”，则应该同时使用@autoclosure和@escaping。

var customersInLine = ["Alex", "Ewa", "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 Alex!
// Now serving Ewa!

print(customersInLine) // ["Barry", "Daniella"]