闭包 Closure

内容摘要：

• 闭包介绍
• 闭包表达式
• 尾随闭包
• 值捕获
• 逃逸闭包
• 自动闭包

一、闭包介绍

闭包是自包含的函数代码块，可以在代码中被传递和使用。函数和闭包都是引用类型

1、闭包的三种形式

• 全局函数是一个有名字但不会捕获任何值的闭包
• 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
• 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

2、Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：

• 利用上下文推断参数和返回值类型
• 隐式返回单表达式闭包，即单表达式闭包可以省略 return 关键字
• 参数名称缩写
• 尾随闭包语法

二、闭包表达式

闭包表达式语法：

{ (parameters) -> returnType in
    statements
}

例如：

let names = ["Chris","Alex","Ewa","Barry","Daniella"]
let reversedNames = names.sorted { (a, b) -> Bool in
    return a > b
}
print("reversedNames = \(reversedNames)")
//reversedNames = ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

1、从语境中推断类型

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

let reversedNames1 = names.sorted { a, b in return a > b }
print("reversedNames1 = \(reversedNames1)")
//reversedNames1 = ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

2、从单表达式闭包隐式返回

单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为作：

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

3、参数名称缩写

Swift 自动为内联闭包提供了参数名称缩写功能，你可以直接通过 1，$2 来顺序调用闭包的参数，以此类推。

let reversedNames3 = names.sorted { $0 > $1 }
print("reversedNames3 = \(reversedNames3)")
//reversedNames3 = ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

4、运算符方法
Swift 的 String 类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值。而这正好与 sorted(by:) 方法的参数需要的函数类型相符合。因此，你可以简单地传递一个大于号，Swift 可以自动推断出你想使用大于号的字符串函数实现：

let reversedNames4 = names.sorted(by: > )
print("reversedNames4 = \(reversedNames4)")

二、尾随闭包

如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函数体部分
}

// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
    // 闭包主体部分
})

// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
    // 闭包主体部分
}

三、值捕获

闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值

var counter = 0
let incrementCounter = {
    counter += 1
}
incrementCounter()
print(counter)  //1
incrementCounter()
print(counter)  //2

四、逃逸闭包

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。

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

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)
// 打印出 "200"

completionHandlers.first?()
print(instance.x)
// 打印出 "100"

五、自动闭包

自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。这种闭包不接受任何参数，当它被调用的时候，会返回被包装在其中的表达式的值。这种便利语法让你能够省略闭包的花括号，用一个普通的表达式来代替显式的闭包

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

let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// 打印出 "5"

print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// 打印出 "4"

六、闭包使用

//一般形式
//有参有反
let testOne: (String, String) -> String = {(str1, str2) in return str1 + str2}
print(testOne("one", "two"))
//无参有反  可以直接省略 "in"
let testTwo: () -> String = {return "test闭包"}
//无参无反
let testThree: () -> Void = {print("test闭包")}

//别名
//可以用"typealias"先声明一个闭包类型
typealias testBlock = (String) -> Void
let aaa: testBlock = {str in
    print(str)
}