创建基础的闭包
Swift使我们可以像使用其他类型一样使用函数，例如字符串和整数。这意味着您可以创建一个函数并将其分配给一个变量，使用该变量调用该函数，甚至将该函数作为参数传递给其他函数。
以这种方式使用的函数称为闭包，尽管它们像函数一样工作，但编写方式有所不同。
让我们从一个简单的示例开始，该示例显示一条消息：
let driving = {
print("I'm driving in my car")
}
这样可以有效地创建一个没有名称的函数，并将该函数分配给driving。现在，您可以driving()像调用常规函数一样进行调用，如下所示：
driving()
在闭包中接受参数
创建闭包时，它们没有名称或空格来写入任何参数。这并不意味着它们不能接受参数，只是它们以不同的方式接受参数：它们在大括号内列出。
要使闭包接受参数，请在开括号后面的括号内列出它们，然后写下in让Swift知道闭包的主体已经开始了
例如，我们可以创建一个接受地名字符串作为其唯一参数的闭包，如下所示：
let driving = { (place: String) in
print("I'm going to \(place) in my car")
}
函数和闭包之间的区别之一是，在运行闭包时不使用参数标签。因此，调用driving()我们现在写成这样：
driving("London")
从闭包中返回值
闭包也可以返回值，它们的写法与参数类似：您可以在闭包内直接在in关键字之前写它们。
为了证明这一点，我们将使用driving()闭包并使其返回其值，而不是直接打印它。这是原始的：
let driving = { (place: String) in
print("I'm going to \(place) in my car")
}
我们希望闭包返回一个字符串而不是直接打印消息，因此我们需要在in之前使用-> String，然后像普通函数一样使用return：
let drivingWithReturn = { (place: String) -> String in
return "I'm going to \(place) in my car"
}
现在，我们可以运行该闭包并打印其返回值：
let message = drivingWithReturn("London")
print(message)
闭包作为参数
因为闭包可以像字符串和整数一样使用，所以可以将它们传递给函数。语法起初会让您头痛，因此我们将慢慢来。
首先，这是我们的基本driving()闭包
let driving = {
print("I'm driving in my car")
}
如果我们想将该闭包传递给函数，以便可以在该函数内部运行，则可以将参数类型指定为() -> Void。这意味着“不接受任何参数，然后返回Void” – Swift所说的“什么都不做”。
因此，我们可以编写一个travel()接受各种旅行行为的函数，并在此之前和之后打印一条消息：
func travel(action: () -> Void) {
print("I'm getting ready to go.")
action()
print("I arrived!")
}
我们现在可以使用driving闭包来调用它，如下所示：
travel(action: driving)
尾随闭包语法
如果函数的最后一个参数是闭包，则Swift可让您使用称为尾随闭包语法的特殊语法。与其在闭包中作为参数传递，不如在括号内的函数之后直接传递它。
为了证明这一点，这又是我们的travel()功能。它接受action闭包，以便可以在两个print()调用之间运行：
func travel(action: () -> Void) {
print("I'm getting ready to go.")
action()
print("I arrived!")
}
因为它的最后一个参数是闭包，所以我们可以使用尾随闭包语法进行调用travel()，如下所示：
travel() {
print("I'm driving in my car")
}
实际上，由于没有任何其他参数，我们可以完全消除括号：
travel {
print("I'm driving in my car")
}
此时会输出如下内容：
I'm getting ready to go.
I'm driving in my car
I arrived!
尾随闭包语法在Swift中非常普遍，因此值得习惯。
当闭包接受参数时，将其用作参数
在这里，可以开始读取闭包，有点像线噪声：传递给函数的闭包也可以接受其自己的参数。
我们用过的() -> Void意思是“不接受任何参数，什么也不返回”，但是您可以继续使用您的闭包()应该接受的任何参数的类型填充。
为了说明这一点，我们可以编写一个travel()函数，该函数接受一个闭包作为唯一参数，然后该闭包又接受一个字符串：
func travel(action: (String) -> Void) {
print("I'm getting ready to go.")
action("London")
print("I arrived!")
}
现在，当我们使用尾随闭包语法进行调用travel()时，需要我们的闭包代码才能接受字符串：
travel { (place: String) in
print("I'm going to \(place) in my car")
}
此时，place的值为func travel(action: (String) -> Void)中action的值。输出内容如下：
I'm getting ready to go.
I'm going to London in my car
I arrived!
返回值时使用闭包作为参数
我们一直在用() -> Void“不接受任何参数，什么也不返回”的意思，但是您可以将其替换Void为任何类型的数据以强制闭包返回一个值。
为了说明这一点，我们可以编写一个travel()函数，该函数接受一个闭包作为其唯一参数，然后该闭包又接受一个字符串并返回一个字符串：
func travel(action: (String) -> String) {
print("I'm getting ready to go.")
let description = action("London")
print(description)
print("I arrived!")
}
现在，当我们使用尾随闭包语法进行调用travel()时，需要我们的闭包代码才能接受字符串并返回字符串：
travel { (place: String) -> String in
return "I'm going to \(place) in my car"
}
速记参数名称
我们刚刚做了一个travel()功能。它接受一个参数，这是一个闭包，其本身接受一个参数并返回一个字符串。然后在两次调用print()之间运行该闭包。
这就是代码中的内容：
func travel(action: (String) -> String) {
print("I'm getting ready to go.")
let description = action("London")
print(description)
print("I arrived!")
}
我们可以这样调用travel()：
travel { (place: String) -> String in
return "I'm going to \(place) in my car"
}
但是，Swift 知道该闭包的参数必须是字符串，因此我们可以将其删除：
travel { place -> String in
return "I'm going to \(place) in my car"
}
它也知道闭包必须返回一个字符串，因此我们可以删除它：
travel { place in
return "I'm going to \(place) in my car"
}
由于闭包只有一行代码必须是返回值的那一行，因此Swift也允许我们删除return关键字：
travel { place in
"I'm going to \(place) in my car"
}
Swift具有简化的语法，可让您走得更短。除了编写place in外，我们还可以让Swift为闭包的参数提供自动名称。这些名称以美元符号命名，然后从0开始计数。
travel {
"I'm going to \($0) in my car"
}
具有多个参数的闭包
为了确保一切都清楚，我们将使用两个参数编写另一个闭包示例。
这次，我们的travel()函数将需要一个闭合符，该闭合符指定某人要去的地方以及他们要走的速度。这意味着我们需要使用(String, Int) -> String参数的类型：
func travel(action: (String, Int) -> String) {
print("I'm getting ready to go.")
let description = action("London", 60)
print(description)
print("I arrived!")
}
我们将使用尾随闭包和简写闭包参数名称来调用它。由于此方法接受两个参数，因此我们将同时获得$0和$1：
travel {
"I'm going to \($0) at \($1) miles per hour."
}
有些人不喜欢使用速记参数名称，$0因为这样可能会造成混淆，这没关系–尽一切可能为您效劳。
从函数返回闭包
和你可以传递一个闭包给函数的方式相同，你也可以从函数获取返回的闭包。
第一次使用的语法有些混乱，因为它使用两次->：一次用于指定函数的返回值，第二次用于指定闭包的返回值。
为了解决这个问题，我们将编写一个不接受任何参数但返回闭包的函数travel()。返回的闭包必须使用字符串调用，并且不会返回任何内容。
这是Swift中的样子：
func travel() -> (String) -> Void {
return {
print("I'm going to \($0)")
}
}
现在，我们可以调用travel()以获取该闭包，然后将其作为函数调用：
let result = travel()
result("London")
从技术上讲是允许的-尽管实际上不建议这样做！–travel()直接从以下位置调用返回值：
let result2 = travel()("London")
值捕获
如果您在闭包内部使用任何外部值，则Swift会捕获它们-将它们存储在闭包旁边，因此即使它们不再存在，也可以对其进行修改。
现在，我们有一个返回闭包的函数travel()，并且返回的闭包接受字符串作为其唯一参数，并且不返回任何内容：
func travel() -> (String) -> Void {
return {
print("I'm going to \($0)")
}
}
我们可以调用travel()以获取闭包，然后自由调用该闭包：
let result = travel()
result("London")
如果我们在闭包内部使用travel()要创建的值，则会发生闭包捕获。例如，我们可能想跟踪返回的闭包被调用的频率：
func travel() -> (String) -> Void {
var counter = 1
return {
print("\(counter). I'm going to \($0)")
counter += 1
}
}
即使该counter变量是在travel()内部创建的，它也会被闭包捕获，因此对于该闭包仍将保持活动状态。
因此，如果我们result("XXXX")多次调用，计数器将不断增加：
result("Beijing")
result("Wuhan")
result("Guangzhou")
此时输出结果如下：
1. I'm going to Beijing
2. I'm going to Wuhan
3. I'm going to Guangzhou
总结
- 1.您可以为变量分配闭包，然后再调用它们。
- 2.闭包可以接受参数和返回值，例如常规函数。
- 3.您可以将闭包作为参数传递给函数，并且这些闭包可以具有自己的参数和返回值。
- 4.如果函数的最后一个参数是闭包，则可以使用尾随闭包语法。
- 5.Swift会自动提供诸如
$0和$1的速记参数名称，但并非所有人都使用它们。 - 6.如果在闭包内部使用外部值，则将捕获它们，以便闭包以后可以引用它们。