从零开始Swift之闭包

闭包

闭包就相当于oc中的block

函数实际上是闭包的一种特殊情况

全局函数式具有名称并且不捕获任何值的闭包

嵌套函数式具有名称的闭包, 并且可以从函数捕获值

闭包表达式是以轻量级语法编写的未命名闭包, 可以从其周围的上下文中捕获值

优化闭包语法可以使用以下几种种方法

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

闭包表达式语法

 {(parameters) -> return type in
       statements
}

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func backward(_ s1: String, _ s2: String) -> Bool {
    return s1 > s2
}
var reversedNames = names.sorted(by: backward)
reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})

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

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

从上下文中推断类型

因为排序闭包作为参数传递给方法, swift可以推断其参数的类型和它的返回值的类型, sort(by:)方法是在字符串数组上调用的, 所以他的参数必须是类型(String, Sting) -> Bool 的参数. 这意味着(String, String) 和Bool类型不需要作为闭包表达式的一部分写入.

所以上面的闭包表达式可以写成

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

单表达式闭包可以通过其声明中省略关键字来隐式返回其单个表达式的结果

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

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

缩短参数名

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

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

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

运算符方法

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

reversedNames = names.sorted(by: >)

尾随闭包

当闭包表达式座位函数的最终参数时,调用时可以省略闭包表达式,就叫做尾随闭包

func someFunctionThatTakesAClosure(closure:() -> Void){
    // 这里写函数主体
}

// 不使用尾随闭包调用这个函数
someFunctionThatTakesAClosure(closure: {
    // 这里写闭包主体
})

// 使用尾随闭包调用这个函数
someFunctionThatTakesAClosure {
    // 尾随闭包的主体写在这里
}

当闭包足够长时,使用尾随闭包对于优化代码是非常有用的

比如下面这个例子

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]
let  stings = numbers.map({
    (number) -> String in
    var number = number
    var output = ""
    repeat{
        output = digitNames[number % 10]! + output
        number /= 10
    }while number > 0
    return output
})

捕捉值

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

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

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

函数捕获的变量可以确保变量不会在调用函数结束时消失,并且还确保在下次调用时可用

let incrementByTen = makeIncrementer(forIncrement: 10)
// 这个例子设置一个名为incrementByTen的常量来引用一个incrementer函数，在每次调用它的runningTotal变量时增加10。 多次调用该函数可显示此行为
incrementByTen()
// 返回值为10
incrementByTen()
// 返回值为20
incrementByTen()
// 返回值为30

逃离闭包

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

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

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

使用@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)
completionHandlers.first?()
print(instance.x)

自动闭包

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

自动闭包让你延迟计算，因为里面的代码不会运行，直到你调用闭包。延迟计算对于具有副作用或计算成本高的代码非常有用，因为它允许您控制何时计算该代码。下面的代码显示了闭包如何延迟计算。(evaluation这个单词找不到合理的解释,暂用计算)

var custometersInLine = ["chris","Alex","Ewa","Barry","Daniella"]
print(custometersInLine.count)// 打印出了 "5"

let customerProvider = {
    custometersInLine.remove(at: 0)
}
print(custometersInLine.count) // 打印了5
customerProvider()
print(custometersInLine.count) // 打印了4

当将闭包作为参数传递给函数时，会得到与延迟计算相同的行为。

func serve(customer customerProvider: () -> String) {
    print("Now servint \(customerProvider())")
}
serve(customer: {custometersInLine.remove(at: 0)})
// 通过使用@autoclosure属性标记其参数的类型来进行自动闭包
func serve(customer customerProvider: @autoclosure () -> String){
    print("Now servint \(customerProvider())")
}

我们再次调用该函数时,更像是调用了一个参数类型为Sting的函数,而不是一个闭包

serve(customer: custometersInLine.remove(at: 0))