以下翻译自Apple官方文档，结合自己的理解记录下来。翻译基于 swift 3.0.1
原文地址
Closures are self-contained blocks of functionality that can be passed around and used in your code. Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.
闭包是一个单独的功能性代码块，可以在你的代码中传递和使用。
Closures can capture and store references to any constants and variables from the context in which they are defined. This is known as closing over those constants and variables. Swift handles all of the memory management of capturing for you.
闭包可以捕获并且存储任意的变量和常量，前提是这些变量和常量是在闭包定义的上下文中。这个被叫做closing over这些变量和常量。swift为你负责处理所有为捕获常量和变量的内存管理。
NOTE
Don’t worry if you are not familiar with the concept of capturing. It is explained in detail below in Capturing Values.
Global and nested functions, as introduced in Functions, are actually special cases of closures. Closures take one of three forms:
全局和嵌套函数事实上是闭包的特殊情况，闭包有以下三种形式：
- Global functions are closures that have a name and do not capture any values.
全局函数：闭包有名字并且不捕获任何变量和常量的情况。这里的全局函数其实就是我们正常定义的函数。- Nested functions are closures that have a name and can capture values from their enclosing function.
嵌套函数：闭包有名字并且从其被包含的函数内部捕获变量和常量的情况。- Closure expressions are unnamed closures written in a lightweight syntax that can capture values from their surrounding context.
闭包表达式：没有名字的闭包，并且以简洁的语法形式存在，能够从其被包裹的上下文中捕获值。
Swift’s closure expressions have a clean, clear style, with optimizations that encourage brief, clutter-free syntax in common scenarios. These optimizations include:
swift的闭包表达式很简洁的风格，并且优化的很好，有着简单、整齐的语法，这些优化包括：
- Inferring parameter and return value types from context
可以从上下文推导参数和返回值类型- Implicit returns from single-expression closures
可以从一个单一表达式隐式的返回- Shorthand argument names
简约表达参数的名称- Trailing closure syntax
后续的闭包语法（不明白，后面看具体解释）
Closure Expressions
Nested functions, as introduced in Nested Functions, are a convenient means of naming and defining self-contained blocks of code as part of a larger function. However, it is sometimes useful to write shorter versions of function-like constructs without a full declaration and name. This is particularly true when you work with functions or methods that take functions as one or more of their arguments.
嵌套函数很方便，但是有时用闭包更简单，可以避免定义函数的声明和名字。尤其在把函数当做函数的一个或多个参数的时候，改用闭包更简单。
Closure expressions are a way to write inline closures in a brief, focused syntax. Closure expressions provide several syntax optimizations for writing closures in a shortened form without loss of clarity or intent. The closure expression examples below illustrate these optimizations by refining a single example of the sorted(by:) method over several iterations, each of which expresses the same functionality in a more succinct way.
闭包优化的很好，可以达到使用函数同样的目的。下面使用sorted方法排序的例子说明闭包的优化是多好，一个优化比一个优化带劲。
The Sorted Method
Swift’s standard library provides a method called sorted(by:), which sorts an array of values of a known type, based on the output of a sorting closure that you provide. Once it completes the sorting process, the sorted(by:) method returns a new array of the same type and size as the old one, with its elements in the correct sorted order. The original array is not modified by the sorted(by:) method.
swift标准库提供了方法sorted(by:)来对数组进行排序，不过需要你提供排序的闭包。sorted(by:)返回一个新的排序后的数组，不对原来的数组做修改。
The closure expression examples below use the sorted(by:) method to sort an array of String values in reverse alphabetical order. Here’s the initial array to be sorted:
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
The sorted(by:) method accepts a closure that takes two arguments of the same type as the array’s contents, and returns a Bool value to say whether the first value should appear before or after the second value once the values are sorted. The sorting closure needs to return true if the first value should appear before the second value, and false otherwise.
这里解释排序的规则，返回true表明第一个值要排在后一个值前面，反之亦然。
This example is sorting an array of String values, and so the sorting closure needs to be a function of type (String, String) -> Bool.
这里要采用的闭包格式
One way to provide the sorting closure is to write a normal function of the correct type, and to pass it in as an argument to the sorted(by:) method:
直接提供函数是闭包的一种方式。像下面这样。
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"]
If the first string (s1) is greater than the second string (s2), the backward(::) function will return true, indicating that s1 should appear before s2 in the sorted array. For characters in strings, “greater than” means “appears later in the alphabet than”. This means that the letter "B" is “greater than” the letter "A", and the string "Tom" is greater than the string "Tim". This gives a reverse alphabetical sort, with "Barry" being placed before "Alex", and so on.
罗里吧嗦下规则
However, this is a rather long-winded way to write what is essentially a single-expression function (a > b). In this example, it would be preferable to write the sorting closure inline, using closure expression syntax.
说下上面直接提供函数的方式不好，太冗长了。看人家下面是怎么做的。
Closure Expression Syntax
闭包表达式的语法
Closure expression syntax has the following general form:
{ (parameters) -> return type in
statements
}
The parameters in closure expression syntax can be in-out parameters, but they can’t have a default value. Variadic parameters can be used if you name the variadic parameter. Tuples can also be used as parameter types and return types.
闭包表达式的参数可以是in-out参数（就是函数参数传址），但是不能有默认值。可变参数可以使用。元组可以用来做参数和返回值。
The example below shows a closure expression version of the backward(::) function from earlier:
闭包版本的backward方法
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
return s1 > s2
})
Note that the declaration of parameters and return type for this inline closure is identical to the declaration from the backward(::) function. In both cases, it is written as (s1: String, s2: String) -> Bool. However, for the inline closure expression, the parameters and return type are written inside the curly braces, not outside of them.
表面看来形式和函数差不多，但是我们的闭包是写在花括号里面的。
The start of the closure’s body is introduced by the in keyword. This keyword indicates that the definition of the closure’s parameters and return type has finished, and the body of the closure is about to begin.
in 这个关键字用来隔离闭包的定义和实现。
Because the body of the closure is so short, it can even be written on a single line:
闭包可以写成一行。
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )
This illustrates that the overall call to the sorted(by:) method has remained the same. A pair of parentheses still wrap the entire argument for the method. However, that argument is now an inline closure.
Inferring Type From Context
从上下文推导类型
Because the sorting closure is passed as an argument to a method, Swift can infer the types of its parameters and the type of the value it returns. The sorted(by:) method is being called on an array of strings, so its argument must be a function of type (String, String) -> Bool. This means that the (String, String) and Bool types do not need to be written as part of the closure expression’s definition. Because all of the types can be inferred, the return arrow (->) and the parentheses around the names of the parameters can also be omitted:
因为负责排序的闭包是作为参数传递给函数的，所以swift可以推导其参数类型和返回值。
reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
It is always possible to infer the parameter types and return type when passing a closure to a function or method as an inline closure expression. As a result, you never need to write an inline closure in its fullest form when the closure is used as a function or method argument.
有了推导这个特性，以后闭包作为函数的参数时就不需要闭包表达式的完整形式了。牛吧！
Nonetheless, you can still make the types explicit if you wish, and doing so is encouraged if it avoids ambiguity for readers of your code. In the case of the sorted(by:) method, the purpose of the closure is clear from the fact that sorting is taking place, and it is safe for a reader to assume that the closure is likely to be working with String values, because it is assisting with the sorting of an array of strings.
尽管如此，但是仍推荐你不要省略参数和返回值，不然你的代码阅读起来会模糊不清。(⊙o⊙)嗯
Implicit Returns from Single-Expression Closures
在明确函数的返回值的情况下，不用再闭包中指明返回值。
Single-expression closures can implicitly return the result of their single expression by omitting the returnkeyword from their declaration, as in this version of the previous example:
reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
Here, the function type of the sorted(by:) method’s argument makes it clear that a Bool value must be returned by the closure. Because the closure’s body contains a single expression (s1 > s2) that returns a Bool value, there is no ambiguity, and the return keyword can be omitted.
Shorthand Argument Names
Swift automatically provides shorthand argument names to inline closures, which can be used to refer to the values of the closure’s arguments by the names $0, $1, $2, and so on.
简约的参数名称。
If you use these shorthand argument names within your closure expression, you can omit the closure’s argument list from its definition, and the number and type of the shorthand argument names will be inferred from the expected function type. The in keyword can also be omitted, because the closure expression is made up entirely of its body:
reversedNames = names.sorted(by: { $0 > $1 } )
Here, $0 and $1 refer to the closure’s first and second String arguments.
Operator Methods
There’s actually an even shorter way to write the closure expression above. Swift’s String type defines its string-specific implementation of the greater-than operator (>) as a method that has two parameters of type String, and returns a value of type Bool. This exactly matches the method type needed by the sorted(by:)method. Therefore, you can simply pass in the greater-than operator, and Swift will infer that you want to use its string-specific implementation:
reversedNames = names.sorted(by: >)
For more about operator method, see Operator Methods.
Trailing Closures
If you need to pass a closure expression to a function as the function’s final argument and the closure expression is long, it can be useful to write it as a trailing closure instead. A trailing closure is written after the function call’s parentheses, even though it is still an argument to the function. When you use the trailing closure syntax, you don’t write the argument label for the closure as part of the function call.
当你的闭包作为函数的最后一个参数时，如果闭包的表达很长，那么你可以使用后续的闭包这种方式来实现。就是在传参时传个闭包表达式的名字，后面再实现这个闭包的body，然后函数被调用的时候可以不需要写闭包表达式的名字。
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（闭包的内容，函数被调用，可以省略闭包的名字）
}
The string-sorting closure from the Closure Expression Syntax section above can be written outside of the sorted(by:) method’s parentheses as a trailing closure:
reversedNames = names.sorted() { $0 > $1 }
If a closure expression is provided as the function or method’s only argument and you provide that expression as a trailing closure, you do not need to write a pair of parentheses () after the function or method’s name when you call the function:
当闭包作为函数的唯一参数时可以省略小括号
reversedNames = names.sorted { $0 > $1 }
Trailing closures are most useful when the closure is sufficiently long that it is not possible to write it inline on a single line. As an example, Swift’s Array type has a map(_:) method which takes a closure expression as its single argument. The closure is called once for each item in the array, and returns an alternative mapped value (possibly of some other type) for that item. The nature of the mapping and the type of the returned value is left up to the closure to specify.
举个map的例子
After applying the provided closure to each array element, the map(_:) method returns a new array containing all of the new mapped values, in the same order as their corresponding values in the original array.
使用map将数字转字符串
Here’s how you can use the map(_:) method with a trailing closure to convert an array of Int values into an array of String values. The array [16, 58, 510] is used to create the new array ["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]
The code above creates a dictionary of mappings between the integer digits and English-language versions of their names. It also defines an array of integers, ready to be converted into strings.
You can now use the numbers array to create an array of String values, by passing a closure expression to the array’s map(_:) method as a trailing closure:
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"]
The map(_:) method calls the closure expression once for each item in the array. You do not need to specify the type of the closure’s input parameter, number, because the type can be inferred from the values in the array to be mapped.
不用指明number的类型，因为有自动推导。
介绍下map的功能。
In this example, the variable number is initialized with the value of the closure’s number parameter, so that the value can be modified within the closure body. (The parameters to functions and closures are always constants.) The closure expression also specifies a return type of String, to indicate the type that will be stored in the mapped output array.
为什么number使用var类型，因为我们要在闭包内修改它，而函数和闭包的参数通常都是常量。
The closure expression builds a string called output each time it is called. It calculates the last digit of numberby using the remainder operator (number % 10), and uses this digit to look up an appropriate string in the digitNames dictionary. The closure can be used to create a string representation of any integer greater than zero.
解释下这里闭包的功能
NOTE
The call to the digitNames dictionary’s subscript is followed by an exclamation mark (!), because dictionary subscripts return an optional value to indicate that the dictionary lookup can fail if the key does not exist. In the example above, it is guaranteed that number % 10 will always be a valid subscript key for the digitNames dictionary, and so an exclamation mark is used to force-unwrap the String value stored in the subscript’s optional return value.
解释下为什么使用digitNames[number % 10]!，强制解析，因为肯定有值啊，这样更有效率。
The string retrieved from the digitNames dictionary is added to the front of output, effectively building a string version of the number in reverse. (The expression number % 10 gives a value of 6 for 16, 8 for 58, and 0 for 510.)
The number variable is then divided by 10. Because it is an integer, it is rounded down during the division, so 16 becomes 1, 58 becomes 5, and 510 becomes 51.
The process is repeated until number is equal to 0, at which point the output string is returned by the closure, and is added to the output array by the map(_:) method.
The use of trailing closure syntax in the example above neatly encapsulates the closure’s functionality immediately after the function that closure supports, without needing to wrap the entire closure within the map(_:) method’s outer parentheses.
Capturing Values（获取值）
A closure can capture constants and variables from the surrounding context in which it is defined. The closure can then refer to and modify the values of those constants and variables from within its body, even if the original scope that defined the constants and variables no longer exists.
定义，和OC block差不多，就是在定义的那瞬间截取变量和常量的值，不管后面上下文怎么修改，或者值都不存在了，在闭包内仍然可以使用这些值。
In Swift, the simplest form of a closure that can capture values is a nested function, written within the body of another function. A nested function can capture any of its outer function’s arguments and can also capture any constants and variables defined within the outer function.
典型的获取值就是嵌套函数。可以获取外层函数的参数，也可以获取外层函数内部定义的变量。
Here’s an example of a function called makeIncrementer, which contains a nested function called incrementer. The nested incrementer() function captures two values, runningTotal and amount, from its surrounding context. After capturing these values, incrementer is returned by makeIncrementer as a closure that increments runningTotal by amount each time it is called.
下面举个例子，函数作为返回值
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
The return type of makeIncrementer is () -> Int. This means that it returns a function, rather than a simple value. The function it returns has no parameters, and returns an Int value each time it is called. To learn how functions can return other functions, see Function Types as Return Types.
The makeIncrementer(forIncrement:) function defines an integer variable called runningTotal, to store the current running total of the incrementer that will be returned. This variable is initialized with a value of 0.
The makeIncrementer(forIncrement:) function has a single Int parameter with an argument label of forIncrement, and a parameter name of amount. The argument value passed to this parameter specifies how much runningTotal should be incremented by each time the returned incrementer function is called. The makeIncrementer function defines a nested function called incrementer, which performs the actual incrementing. This function simply adds amount to runningTotal, and returns the result.
When considered in isolation, the nested incrementer() function might seem unusual:
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
The incrementer() function doesn’t have any parameters, and yet it refers to runningTotal and amount from within its function body. It does this by capturing a reference to runningTotal and amount from the surrounding function and using them within its own function body. Capturing by reference ensures that runningTotal and amount do not disappear when the call to makeIncrementer ends, and also ensures that runningTotal is available the next time the incrementer function is called.
闭包会通过reference（引用）的方式访问上下文中的变量，这样能够保证这些变量在外层函数调用结束后不会消失（自然我们会想到block的循环引用问题，就是这么来的），因此，下次我们仍然可以在下次外层函数被调用的时候访问到这些变量。
NOTE
As an optimization, Swift may instead capture and store a copy of a value if that value is not mutated by a closure, and if the value is not mutated after the closure is created.
Swift also handles all memory management involved in disposing of variables when they are no longer needed.
作为优化，swift在闭包中可能会替换引用的方式，转而使用存储一份拷贝的方式，前提是如果这些值不会被闭包改变并且不会在闭包创建后被修改。
Here’s an example of makeIncrementer in action:
下面看例子
let incrementByTen = makeIncrementer(forIncrement: 10)
This example sets a constant called incrementByTen to refer to an incrementer function that adds 10 to its runningTotal variable each time it is called. Calling the function multiple times shows this behavior in action:
incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30
If you create a second incrementer, it will have its own stored reference to a new, separate runningTotalvariable:
let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7
Calling the original incrementer (incrementByTen) again continues to increment its own runningTotalvariable, and does not affect the variable captured by incrementBySeven:
incrementByTen()
// returns a value of 40
NOTE
If you assign a closure to a property of a class instance, and the closure captures that instance by referring to the instance or its members, you will create a strong reference cycle between the closure and the instance. Swift uses capture lists to break these strong reference cycles. For more information, see Strong Reference Cycles for Closures.
这里就说到了将闭包赋值给一个类的实例属性时，并且闭包通过索引的方式访问实例本身或者实例的成员变量，你将会在闭包和实例之间创建一个强引用循环。swift用闭包列表来打破这个循环引用。（后面看看闭包列表是啥）
Closures Are Reference Types
In the example above, incrementBySeven and incrementByTen are constants, but the closures these constants refer to are still able to increment the runningTotal variables that they have captured. This is because functions and closures are reference types.
Whenever you assign a function or a closure to a constant or a variable, you are actually setting that constant or variable to be a reference to the function or closure. In the example above, it is the choice of closure that incrementByTen refers to that is constant, and not the contents of the closure itself.
This also means that if you assign a closure to two different constants or variables, both of those constants or variables will refer to the same closure:
let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// returns a value of 50
记住闭包是引用类型。
Escaping Closures
A closure is said to escape a function when the closure is passed as an argument to the function, but is called after the function returns. When you declare a function that takes a closure as one of its parameters, you can write @escaping before the parameter’s type to indicate that the closure is allowed to escape.
这里Escaping翻译成脱离吧，如果一个闭包作为一个函数的参数，但是闭包的调用是在函数执行完也就是return以后，那么我们称这个闭包脱离了这个函数。当我们传递一个闭包作为函数的参数时，可以在参数的类型后加上@escaping来指明这个闭包可以被允许脱离函数。在swift12版本，闭包默认是都可以脱离的，但是在现在这个swift3版本，闭包默认是不可以脱离的。
One way that a closure can escape is by being stored in a variable that is defined outside the function. As an example, many functions that start an asynchronous operation take a closure argument as a completion handler. The function returns after it starts the operation, but the closure isn’t called until the operation is completed—the closure needs to escape, to be called later. For example:
脱离函数的一种方式就是将闭包存储在外层函数之外的一个变量内。还有一个就是异步执行。
例如：网络请求完成后的回调。
这里文档举了一个第一个类型的脱离情况，也就是将闭包存储在外层函数之外的一个变量内的情况。
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
The someFunctionWithEscapingClosure(_:) function takes a closure as its argument and adds it to an array that’s declared outside the function. If you didn’t mark the parameter of this function with @escaping, you would get a compiler error.
这里必须将completionHandler这个参数指明为@escaping类型的，因为在函数内部，它是被加到一个数组中的，而这个数组中的闭包何时执行，谁也不知道，所以它是脱离函数类型的闭包。
Marking a closure with @escaping means you have to refer to self explicitly within the closure. For example, in the code below, the closure passed to someFunctionWithEscapingClosure(:) is an escaping closure, which means it needs to refer to self explicitly. In contrast, the closure passed to someFunctionWithNonescapingClosure(:) is a nonescaping closure, which means it can refer to selfimplicitly.
还有一个重要的地方就是，脱离函数的闭包内部必须使用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)
// Prints "200"
completionHandlers.first?()
print(instance.x)
// Prints "100"
Autoclosures
An autoclosure is a closure that is automatically created to wrap an expression that’s being passed as an argument to a function. It doesn’t take any arguments, and when it’s called, it returns the value of the expression that’s wrapped inside of it. This syntactic convenience lets you omit braces around a function’s parameter by writing a normal expression instead of an explicit closure.
自动闭包是自动创建并压缩表达式当传递给一个函数的参数时，它不需要带任何参数，当其被调用时，会返回当初被压缩的表达式。说白了，就是帮我们省略了一个花括号。
It’s common to call functions that take autoclosures, but it’s not common to implement that kind of function. For example, the assert(condition:message:file:line:) function takes an autoclosure for its condition and message parameters; its condition parameter is evaluated only in debug builds and its message parameter is evaluated only if condition is false.
而通常情况下，我们只调用参数类型是自动闭包的函数，而不会去实现这种函数。例如：assert函数。
An autoclosure lets you delay evaluation, because the code inside isn’t run until you call the closure. Delaying evaluation is useful for code that has side effects or is computationally expensive, because it lets you control when that code is evaluated. The code below shows how a closure delays evaluation.
自动闭包帮助我们实现延时调用，因为什么时候我们调用这个闭包，什么时候这个闭包才会进行解析，返回当初压缩的表达式。下面是个延时的例子
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"
Even though the first element of the customersInLine array is removed by the code inside the closure, the array element isn’t removed until the closure is actually called. If the closure is never called, the expression inside the closure is never evaluated, which means the array element is never removed. Note that the type of customerProvider is not String but () -> String—a function with no parameters that returns a string.
customerProvider不是string类型，而是一个() -> String的函数
You get the same behavior of delayed evaluation when you pass a closure as an argument to a function.
// 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!"
上面是不带自动闭包类型的函数调用
The serve(customer:) function in the listing above takes an explicit closure that returns a customer’s name. The version of serve(customer:) below performs the same operation but, instead of taking an explicit closure, it takes an autoclosure by marking its parameter’s type with the @autoclosure attribute. Now you can call the function as if it took a String argument instead of a closure. The argument is automatically converted to a closure, because the customerProvider parameter’s type is marked with the @autoclosure attribute.
下面是带自动闭包类型的函数调用
// 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!"
NOTE
Overusing autoclosures can make your code hard to understand. The context and function name should make it clear that evaluation is being deferred.
不要过度使用自动闭包，否则会导致你的代码难以理解。如果有延时调用的情况发生，那么在上下文或者函数的名称上要体现出来。
If you want an autoclosure that is allowed to escape, use both the @autoclosure and @escaping attributes. The @escaping attribute is described above in Escaping Closures.
最后举个自动闭包和脱离闭包的混合例子
// 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!"
In the code above, instead of calling the closure passed to it as its customerProvider argument, the collectCustomerProviders(_:) function appends the closure to the customerProviders array. The array is declared outside the scope of the function, which means the closures in the array can be executed after the function returns. As a result, the value of the customerProvider argument must be allowed to escape the function’s scope.
总结：闭包概念还是比较简单的，只是表现形式较多，需要多实践掌握！