Swift闭包详解（Closures）

闭包是自包含的功能块，可以在代码中传递和使用。 Swift中的闭包类似于C和Objective-C中的块以及其他编程语言中的lambdas。
闭包可以捕获和存储对定义它们的上下文中的任何常量和变量的引用。这被称为关闭那些常量和变量。 Swift为您处理捕获的所有内存管理。
函数中引入的全局函数和嵌套函数实际上是闭包的特例。闭包采用以下三种形式之一：

全局函数是具有名称但不捕获任何值的闭包；
嵌套函数是具有名称的闭包，可以从其封闭函数中捕获值；
闭包表达式是一种未命名的闭包，用轻量级语法编写，可以从周围的上下文中捕获值；
Swift的闭包表达式具有干净，清晰的风格，可以优化在常见场景中的一些无杂乱语法。这些优化包括：
从上下文中推断参数和返回值类型；
单表达式闭包的隐式返回；
速记参数名称；
尾随闭包语法；

一、闭包表达式

（一）排序方法


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"]

（二）闭包表达式语法

{ (parameters) -> return type in
    statements
}

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: >)

二、尾随闭包

如果你需要向函数传递一个闭包表达方式，将其作为函数的最后一个参数，并且该闭包表达式较长，这时可以使用尾随闭包来代替。
尾随闭包写在函数调用的括号之后，虽然它仍是函数的参数。使用尾随闭包语法时，不要将闭包的参数标签作为函数调用的一部分。


let digitNames:[Int:String] = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]

let results = digitNames.map { (key,value) -> String in
    
    return "\(value)=\(key)"
}

三、捕获值

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

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

let incrementByTen = makeIncrementer(forIncrement: 10)

incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30

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

incrementByTen()
// returns a value of 40

四、闭包是引用类型

在上面的示例中，incrementBySeven和incrementByTen是常量，但这些常量引用的闭包仍然能够增加它们捕获的runningTotal变量。这是因为函数和闭包是引用类型。
无论何时将函数或闭包赋值给常量或变量，实际上都是将该常量或变量设置为对函数或闭包的引用。在上面的示例中，incrementByTen引用的闭包选择是常量，而不是闭包本身的内容。
这也意味着如果为两个不同的常量或变量分配闭包，那么这两个常量或变量都引用相同的闭包。

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

incrementByTen()
// returns a value of 60

五、逃离闭包

将闭包作为参数传入函数，但在函数返回之后调用这个闭包，我们称该闭包逃离了函数。当声明一个带有闭包参数的函数时，可以将@escaping写在参数类型前面，指明该闭包允许逃离函数。
闭包逃离的一种方式是将闭包存储在函数体外的变量中。

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

上面示例中的serve(customer:)函数采用显式闭包，返回客户的名称。下面示例中的serve(customer:)函数执行相同的操作，但不是采用显式闭包，而是通过使用@autoclosure属性标记其参数类型来采用自动闭包。现在你可以调用函数，就像它使用字符串参数而不是闭包。参数将自动转换为闭包，因为customerProvider参数的类型标有@autoclosure属性。

// 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!"

过度地使用自动关闭会使代码难以理解。上下文和函数名应该清楚地表达正在进行延迟计算。

如果你允许一个闭包逃离，需要同时使用 @autoclosure 和@escaping属性。

// 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!"

七、其他专题模块

Swift 4.2 基础专题详解