闭包可以从定义它们的上下文中捕获和存储对任何常量和变量的引用。 这被称为关闭这些常量和变量。 Swift处理所有的捕获的内存管理。

在函数中介绍的全局和嵌套函数实际上是闭包的特殊情况。 关闭采取以下三种形式之一：

• 全局函数是具有名称并且不捕获任何值的闭包。
• 嵌套函数是具有名称的闭包，并且可以从其封闭函数捕获值。
• 闭包表达式是以轻量级语法编写的未命名闭包，可以从其周围的上下文中捕获值。

Swift的闭包表达式有一个干净，清晰的风格。 这些优化包括：

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

闭包表达式

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

Swift的标准库提供了一个名为sorted（by :)的方法，它根据您提供的排序闭包的输出对已知类型的值进行排序。 一旦完成排序过程，sorted（by :)方法返回一个与旧的数组相同类型和大小的新数组，其元素以正确的排序顺序。 原始数组不会被sorted（by :)方法修改。

下面的闭包表达式示例使用sorted（by :)方法以相反的字母顺序对String值数组进行排序。 这里是要排序的初始数组：

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

sorted（by :)方法接受一个闭包，它接受与数组内容相同类型的两个参数，并返回一个Bool值，以说明在值排序后第一个值是在第二个值之前还是之后。 如果第一个值应该出现在第二个值之前，那么排序闭包需要返回true，否则返回false。

此示例对String值数组进行排序，因此排序闭包需要是类型（String，String） - > Bool的函数。

提供排序闭包的一种方法是编写正确类型的正常函数，并将其作为参数传递给sorted（by :)方法：

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）。 在这个例子中，最好使用闭包表达式语法写入排序闭包。

闭包表达式语法

Closure表达式语法具有以下一般形式：

{ (parameters) -> return type in
    
    statements
    
}

闭包表达式语法中的参数可以是输入输出参数，但它们不能具有默认值。 如果命名variadic参数，可以使用可变参数。 元组也可以用作参数类型和返回类型。

下面的示例显示了来自早期的向后（： :)函数的闭包表达式版本：

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

请注意，此内联闭包的参数声明和返回类型与后向（： :)函数的声明相同。 在这两种情况下，它被写为（s1：String，s2：String） - > Bool。 但是，对于内联闭包表达式，参数和返回类型写在大括号内，而不是在大括号外。

闭包的主体的开始由in关键字引入。 此关键字表示闭包的参数和返回类型的定义已完成，闭包的主体即将开始。

因为闭包的主体是这么短，它甚至可以写在一行：

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

这说明对sort（）方法的整体调用保持不变。 一对括号仍然包装该方法的整个参数。 然而，这个参数现在是一个内联闭包。

从上下文中推断类型

因为排序闭包作为参数传递给方法，Swift可以推断其参数的类型和它返回的值的类型。 对字符串数组调用sorted（by :)方法，因此它的参数必须是类型（String，String） - > Bool的函数。 这意味着（String，String）和Bool类型不需要作为闭包表达式定义的一部分写入。 因为可以推断所有类型，所以也可以省略返回箭头（ - >）和参数名称周围的括号：

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

当将闭包传递到函数或方法作为内联闭包表达式时，总是可以推断参数类型和返回类型。 因此，当闭包用作函数或方法参数时，您不需要以其最完整的形式编写内联闭包。

但是，如果您愿意，您仍然可以使类型显式，并且如果它避免您的代码的读者的歧义，鼓励这样做。 在sorted（by :)方法的情况下，闭包的目的是清楚的，因为排序正在进行，读者可以假定闭包很可能使用String值，这是安全的，因为 它协助排序字符串数组。

单表达式闭包的隐式返回

单表达式闭包可以通过在其声明中省略return关键字来显式返回其单个表达式的结果，如在上一个示例的此版本中：

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

这里，sorted（by :)方法的参数的函数类型清楚地表明，Bool值必须由闭包返回。 因为闭包的主体包含一个返回Bool值的单个表达式（s1> s2），所以没有歧义，并且可以省略return关键字。

速记参数名称

Swift自动为内联闭包提供了速记参数名称，可以用来通过名称$ 0，$ 1，$ 2等引用闭包的参数的值。

如果在闭包表达式中使用这些速记参数名称，则可以从其定义中省略闭包的参数列表，并且将从预期的函数类型推断速记参数名称的数量和类型。 也可以省略in关键字，因为闭包表达式完全由其主体组成：

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

这里，$ 0和$ 1引用闭包的第一个和第二个String参数。

运算符方法

实际上有一个更短的方式来编写上面的闭包表达式。 Swift的String类型定义了大于运算符（>）的字符串特定实现，作为一个具有两个类型为String的参数的方法，并返回一个Bool类型的值。 这与sorted（by :)方法所需的方法类型完全匹配。 因此，您可以简单地传入greater-than运算符，Swift将推断您要使用其字符串特定的实现：

reversedNames = names.sorted(by: >)

尾随闭包

如果你需要将一个闭包表达式作为函数的最后一个参数传递给一个函数，而闭包表达式是long，那么将它作为一个尾随闭包来写是很有用的。 尾随闭包写在函数调用的括号后面，即使它仍然是函数的参数。 当使用尾随闭包语法时，不要将闭包的参数标签写为函数调用的一部分。

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
}

上面的Closure Expression语法部分中的字符串排序闭包可以在排序（by）方法的括号外作为尾随闭包写入：

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

如果一个闭包表达式作为函数或方法的唯一参数，并且你提供该表达式作为尾随闭包，那么在调用函数时，不需要在函数或方法名称后面写入一对括号（）：

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

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

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

以下是如何使用map（_ :)方法与一个尾随闭包将Int值数组转换为String值数组。 数组[16,58,510]用于创建新数组[“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]

上面的代码创建了一个字典的整数位数和他们的名字的英语版本之间的映射。 它还定义了一个整数数组，准备转换为字符串。

现在，您可以使用numbers数组创建一个String值数组，方法是将闭包表达式传递给数组的map（_ :)方法作为尾随闭包：

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

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

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

闭包表达式在每次被调用时构建一个名为output的字符串。 它使用余数运算符（数字％10）计算数字的最后一位数字，并使用此数字在digitNames字典中查找合适的字符串。 闭包可以用于创建大于零的任何整数的字符串表示。

捕获值

闭包可以从定义它的周围环境捕获常量和变量。 然后，闭包可以引用并修改那些常量和变量的值，即使定义常量和变量的原始作用域不再存在。

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

这里有一个名为makeIncrementer的函数示例，它包含一个名为incrementer的嵌套函数。 嵌套的incrementer（）函数从其周围的上下文中捕获两个值，即runningTotal和amount。 捕获这些值之后，incrementer由makeIncrementer返回，作为每次调用时将runningTotal增量的闭包。

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

incrementer（）函数没有任何参数，但它从函数体内引用runningTotal和amount。 它通过从周围函数捕获对runningTotal和amount的引用，并在其自身的函数体中使用它们。 通过引用捕获确保runningTotal和amount不会在调用makeIncrementer结束时消失，并且还确保runningTotal在下次调用incrementer函数时可用。

作为优化，如果该值未被闭包改变，并且该值在创建闭包后未被改变，Swift可能会捕获并存储值的副本。Swift还处理在不再需要时处理变量所涉及的所有内存管理。

这里有一个示例

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

闭包是引用类型

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

无论何时将函数或闭包分配给常量或变量，实际上都将该常量或变量设置为函数或闭包的引用。

在上面的示例中，它是incrementByTen引用的闭包的选择，它是常量，而不是闭包本身的内容。这也意味着，如果你为两个不同的常量或变量赋值一个闭包，那么这两个常量或变量都将引用相同的闭包：

逃离闭包

当闭包作为参数传递给函数时，闭包被称为逃逸函数，但在函数返回后被调用。 当你声明一个函数将闭包作为其参数之一时，你可以在参数的类型之前写入@escaping，以指示允许闭包逃逸。

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

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

someFunctionWithEscapingClosure（_ :)函数接受一个闭包作为其参数，并将其添加到在函数外声明的数组。 如果你没有用@escaping标记这个函数的参数，你会得到一个编译错误。

使用@escape标记闭包意味着你必须在闭包内自我引用。 例如，在下面的代码中，传递给someFunctionWithEscapingClosure（_ :)的闭包是一个转义闭包，这意味着它需要自我引用。 相反，传递给someFunctionWithNonescapingClosure（_ :)的闭包是一个非转义闭包，这意味着它可以自我引用。

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"

自动闭包

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

autoclosure让你延迟评估，因为里面的代码不会运行，直到你调用闭包。延迟评估对于具有副作用或计算成本高昂的代码非常有用，因为它允许您控制何时评估该代码。下面的代码显示了闭包如何延迟评估。

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数组的第一个元素被closure中的代码删除，数组元素也不会被删除，直到闭包被实际调用。 如果闭包从未被调用，则闭包中的表达式将永远不会被计算，这意味着数组元素永远不会被移除。 注意，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!"

上面的列表中的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))
// 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!"

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