Swift-- 闭包

闭包是自包含的功能块，能够在代码中传递和使用。Swift闭包与c和oc中的block相似，其余语言用lambdas。

闭包能够获取和存储指向在闭包内部定义的任何常量和变量，这就是所谓的封闭常量和变量，swift为你处理全部的捕捉的内存管理。

注意：若是你对捕捉的概念不熟悉，不用担忧，在Capture Value中会详情的说明。

 

已经在Function中介绍的全局方法和嵌套方法，其实是Closures的一个中特殊例子。Closures采用三种形式之一：

• 全局函数是一种 有个名字可是没有捕获任何值的闭包函数。
• 嵌套函数是一种 有一个函数名而且能够从他们的闭包函数中获取到值的闭包。
• 闭包表达式是使用轻量级语法编写的闭包，能够从周围环境捕获值。

Swift的闭包表达式有一种干净、清晰的风格，在常见的场景中使用了鼓励简短、无规则的语法的优化。这些优化包括：

从上下文推断参数和返回值类型

来自间单表达式闭包的隐式返回

速记参数名称

后关闭的语法

 

1.闭包的表达式

嵌套函数，是一种方便命名和定义自包函数块的方法，做为一个大函数的一部分。然而，有时候编写一个间断的不带完整的声明和命名的函数结构是颇有用的，尤为是在须要用函数做为一个或者多个函数或者方法的参数的时候。

闭包表达式一种是简洁、集中的语法编写的内联闭包的方法。闭包表达式提供了一些语法优化，能够在短表单中编写闭包，而不会失去清晰或意图。下面闭包表达式的例子说明了这些优化，经过从新定义sorted(by:)函数，每一个表达式都以更简洁的方式表达相同的功能。

（1）排序方法

Swift标准库提供一个sroted（by：）的方法，基于你提供的排序闭包输出，给一个已知类型的数组排序。一旦这个排序完成，sorted（by：）方法返回一个新的按照正确顺序排过序的数组，数组的类型和大小都与旧的数组一致。原始的数组不会被修改。

下面闭包表达式的例子用sorted(by:)方法为一个字符串数组按照字母顺序排序。排序(经过:)方法接受一个闭包，该闭包接受与数组内容相同类型的两个参数，并返回Bool值，以肯定一旦值被排序，第一个值是否应该出如今第二个值以前或以后。若是第一个值出如今第二个值以前，那么排序结束须要返回true，不然将返回false。

这个例子是对字符串数组进行排序的，所这个排序的闭包须要函数类型为(String, String) -> Bool.

提供排序闭包的一个方法是写一个普通正确类型的函数，把这个函数对坐sorted(by:)方法的参数传递进去。

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

 若是第一个字符（S1）比第二个字符串（S2）大，backward(_:_:)这个函数会返回true，说明在排序数组中S1应该拍在S2前面。

（2）闭包表达式的语法

{ (parameters) -> return type in
    statements
}

 在闭包表达式中的语法中，参数能够用输入输出参数，但他们不能有默认的值。当你命名参数变量的时候，变量参数可使用，元组也能够做为闭包表达式的参数。

前面提到的 backward(_:_:)函数能够用下面的方法来表示：

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

 注意的是，在函数 backward(_:_:)的声明与内联闭包函数声明参数和返回值类型是同样的。这个两个例子中，都写成：(s1: String, s2: String) -> Bool。然而，在内联函数闭包表达中，参数和返回值都写在花括号内，而不是外部。

闭包函数体以“in”关键字为开始。这个关键字表示这个闭包的参数和返回值类型已经完成，而闭包体刚刚开始。

若是闭包体很短，能够写在同一行里：

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

 （2）从上下文中推断类型

由于闭包函数做为一个参数传给一个方法，Swift能够推断这个参数的类型以及这个返回值的类型。sprted(by:)这个方法在字符串数组调用的时候，它的参数必须（String, String）->Bool 的函数类型。意味着（String, String）和  Bool 类型不须要做为闭包表达式定义的一部分。由于全部的类型都是推断，返回箭头(->)和参数名字的括号也能够省略。

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

 当将闭包传给一个函数或者方法做为内联闭包表达时，一般都是能够推断出参数的类型和返回值类型的。

固然，若是你想的话，仍然让你的类型清晰一点，若是为了你的代码读起来避免模凌两可的时候仍是鼓励你们那么坐的。

（3）从简单闭包表达式返回一个精确的值

简单表达式的闭包，在他们的表达式声明中省略return关键字，也能够精确返回一个结果。

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

 这里，sorted(by:)方法的参数的函数类型让这个方法很清晰明白，这个闭包确定返回一个Bool值。

（4）缩短参数名

SSwift自动为内联闭包提供了简短的参数名称，能够用来引用闭包参数的值，名称为$ 0、$ 一、$ 2，等等。

若是你在闭包表达式中用这些短参数的话，你能够在定义闭包的时候，省略参数列表。短参数的名称的个数和类型能够从指定的参数类型来推断出来。in关键字也能够被忽略，由于闭包表达式彻底由它的闭包体组成。

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

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

（5）操做方法

上面的闭包闭包表达式中还有一个更简短的方法。Swift的String类型定义了比操做符（>）作为一种具备两个字符串类型的参数和返回一个bool类型值的方法。所以，你能够简单地传一个比操做符，Swift会自动推断出你想用它的string-specific功能。

reversedNames = names.sorted(by: >)

 想了解更多操做方法，请看“ Operator Methods”。

 

2.尾随闭包

若是你须要给一个函数传入一个闭包表达式做为函数最后的参数，并且这个闭包表达式很长的话， 你能够用尾随闭包来代替。尾随闭包写在函数调用的括号后面，可是它仍然是这个函数的参数。当你使用尾随闭包语法的时候，你不须要将闭包的参数标签写为函数调用的一部分。

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
}

 在闭包表达式语法部分中的字符串排序闭包，能够写在sroted（by：）方法括号外面做为尾随闭包：

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

 若是一个闭包表达式做为一个函数或者方法的惟一参数，并且你提供的这个表达式做为尾随闭包，则当你调用这个方法的时候，你不须要在函数和方法名的后面写（）。

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

 当闭包比较长以致于在内联函数中一行写不下时，用尾随闭包是至关有用的。例如，Swift 的数组类型有个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 是有闭包参数number初始化的值，因此这个值能够在闭包体中修改。（方法和闭包的参数始终都是常量）。闭包表达式也制定了一个返回类型String，为了代表在映射输出的数组中用这个类型排序。

这个闭包表达式被调用的时候会构建一个output的字符串。它经过使用剩余的运算符来计算最后一个数字(number % 10)，而后用这个数字在digitNames的字典中，查找是否有匹配的字符串。

注意：对digitNames字典的下标的调用后面跟着一个感叹号(!)，由于字典子脚本返回一个可选的值，以代表若是键不存在，字典查找就会失败。在上面的示例中，能够保证number % 10始终是数字字典的一个有效的下标键，所以使用感叹号来强制解压存储在下标可选返回值中的字符串值。

从digitNames字典中取得的字符串会添加在output前面，有效的构建了这个数字转换后的字符串。

变量number被10整除，由于它是一个整数，它在除法中是圆形的，因此，16变成了1，58变成了5，510变成了51.

这个过程一直重复知道这个number等于0，与此同时，output字符串也从闭包中返回，并添加到了map(_:) 方法的输出数组中。

在上述尾随闭包语法中，当函数的闭包一提供，就能够封装闭包功能，不须要在map(_:)方法的()内部封装整个闭包。

3.捕获值

一个闭包能够根据它定义的上下文来获取一个常量和变量。闭包能够在它的闭包体中引用和修改这些常量和变量的值，即便在最初定义的常量和变量的做用域再也不存在。

在Swift中，能够捕获值的闭包最简单形式是嵌套函数，在闭包体中编写另一个方法。一个嵌套函数能够获取到在它外面函数的参数，而且能够获取这些外函数定义的常量和变量。

这个例子就是一个叫makeIncrementer函数，它包含了一个嵌套函数incrementer。这个嵌套函数incrementer()函数能够从上下文中获取到两个值runningTotal和amount。获取到这两个值后，makeIncrementer将incrementer做为闭包返回，每次调用时递增。

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

 makeIncrementer的返回类型是()->Int,这意味着它返回的是一个函数，而不是一个值。这个返回的函数没有参数，每次调用的时候返回Int值。

makeIncrementer(forIncrement:)函数定义一个runningTotal的整型变量，存储incrementer中正在运行总数的值，而且返回。这个整数初始化为0.

makeIncrementer(forIncrement:)函数有一个Int类型的参数，参数标签为forIncrement,参数名为amount。当调用incrementer这个方法时，传入参数指定runningTotal每次返回时增长了多少。在makeIncrementer函数中定义个了一个嵌套函数叫作incrementer，这个嵌套函数的做用是增长。这个嵌套函数只是简单地把amount与runningTotal的值相加，并返回相加的结果。

若是单独考虑这个嵌套函数，会以为很奇怪：

func incrementer() -> Int {
    runningTotal += amount
    return runningTotal
}

 incrementer()函数没有任何的参数，它仍然在闭包体中引用runningTotal和amount。它从上下文函数中捕获了runnintTotal和amoun值，并在本身的函数体中使用了它们。经过引用获取值能够确保runningTotal和amount不会消失当makeIncrementer调用结束后，并且确保下一次incrementer函数调用的时候，runningTotal是有效的。

注意：

做为一种优化，若是不经过闭包来改变值，那么Swift能够捕获并存储一个值的副本，若是在建立了闭包以后值没有发生突变，则能够保存该值的副本。

Swift还处理在再也不须要时处理变量的全部内存管理。

下面是makeIncrementer的调用：

let incrementByTen = makeIncrementer(forIncrement: 10)

这个示例设置了一个名为incrementByTen的常量，以引用一个递增函数，每次调用它时，它都会为它的runningTotal变量增长10个变量若是屡次调用这个函数，那么结果以下：

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

 若是你再建立一个递增函数，它将有它本身的存储引用到一个新的、独立的runningTotal变量:

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

 再一次调用incrementerByTen，会继续增长它本身的runningTotal变量，不会影响incrementBySeven的变量。

incrementByTen()
// returns a value of 40

 注意：若是你给一个类对象设置了闭包属性，并且这个闭包经过引用这个实例或者它的成员获取到这个实例，你会在闭包和实例中建立强的循环引用。

 

4.闭包是引用类型

上述的例子中，incrementBySeven和incrementByTen是常量，可是闭包常量的引用依然能够增长捕获到的runningTotal变量的值。这是由于函数和闭包都是引用类型。

不管何时，你分配一个函数或者闭包给一个常量或者变量，你其实是把这个常量和变量指向了函数或者闭包。上面的例子，incrementByTen指的是一个常量，不是指闭包的内容。

它意味着若是你分配一个闭包给两个不一样的变量或者常量，这两个常量或者变量指向相同的闭包：

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

 5.逃离闭包

若是一个闭包当成一个函数的参数传入时，这个闭包称之为逃离函数，可是它是在函数返回时才调用的。当你声明一个函数，函数的其中一个参数是闭包，你能够在参数类型前面写上“@escaping”代表闭包是容许逃离的。

还有一个闭包能够escape的方法是：经过存储在一个定义在函数以外的变量上。例如，许多启动异步操做的函数采用闭包参数做为完成处理程序。这个函数在操做开始时返回，可是闭包不会被调用知道这个操做完成--闭包须要转义，稍后调用。例如：

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

 someFunctionWithEscapingClosure(_:)函数参数类型是闭包，并把它添加到在函数外的一个数组中。若是你不在函数的参数上标记“ @escaping”，会提示编辑时错误。

经过@escape来控制闭包意味着您必须在闭包中显式地引用自显。例如,在下面的代码中,闭包传递给someFunctionWithEscapingClosure(_:)是一种escape closure,这意味着它须要显式地引用self。相比之下,闭包传递给someFunctionWithNonescapingClosure(_:)是一个nonescaping closure,这意味着它能够指自我暗示。

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"

 

6.自动闭包

自动闭包是一个闭包，它是自动建立的、用来做为函数参数的表达式。调用的时候，不须要传入任何的参数，返回这个表达式的值。这种句法方即可以让您在函数的参数周围省略大括号，而不是显式的closur，而是编写一个正常的表达式。

经过自动闭包调用函数是很正常的，可是实现这种方法并不常见。例如： assert(condition:message:file:line:)函数用自动闭包做为condition和message的参数，condition这个参数只有在编译debug时才调用，而message只有在condition为false时才调用。

一个自动闭包让你延迟评估，由于内部代码不会执行知道你调用这个闭包。延迟评估对有反作用或者计算费用很昂贵的代码颇有用，由于它让你控制代码何时评估。下面的代码显示了一个闭包若是延迟评估。

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数组的第一个元素在闭包的内部已经被移除，可是数组的元素并不会真的移除粗肥闭包真的被调用了。若是闭包没有被调用，这个闭包的表达式不会被评估，也就是说数组中的元素永远不会被移除。注意，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做为闭包。

注意：过分使用自动闭包会让你代码看起来费力。

若是你想用一个自动闭包来容许逃逸，用 @autoclosure and @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!"