1、闭包的概念

• 闭包是可以在代码中被传递和引用的功能性独立代码块，跟C和Objective-C中的代码块(blocks)和其他一些语言中的匿名函数相似
• 闭包可以作为函数的参数也可以作为函数的返回值
• 可以像oc中用于回调和反向传值
• 闭包能够捕获和存储定义在其上下文中的任何常量和变量的引用
• 全局和内嵌函数，实际上是特殊的闭包。闭包符合如下三种形式中的一种:

1. 全局函数是一个有名字但不会捕获任何值的闭包
2. 内嵌函数是一个有名字且能从其上层函数捕获值的闭包
3. 闭包表达式是一个轻量级语法所写的可以捕获其上下文中常量或变量值的没有名字的闭包

2、闭包表达式

1> 语法形式为
{
(参数列表) -> 返回值类型 in 函数体代码
}
2> 相关书写规则

1. 参数可以有多个，多个参数用,隔开
2. 参数列表的小括号可以省略
3. 返回值类型也可以省略
4. 当没有参数时in可以省略
5. in可以看作是一个分隔符，将函数体和前面的参数、返回值分隔开来
6. 单表达式闭包隐式返回可以省略 return 关键字

3> 闭包表达式的种类

• 1.有参有返回值

//有参数有返回值
//右边是严格按照了闭包表达式来写的，有参数，有括号，有返回值。
let testOne:(String, String) -> String = { (s1: String, s2: String) -> String in
    return s1 + s2
}
print(testOne("test", "one"))
//下面再看下闭包表达式的简写
//这个跟上一个是等价的，闭包表达式省去了参数的括号,返回箭头以及返回值类型.因为swift编译器能自动根据 = 去做类型判断,从而推断出相关类型
let testOne2:(String, String) -> String = { s1, s2 in
    return s1 + s2
}
print(testOne2("test", "one"))

• 无参无返回值

//无参数无返回值
let testOne:() -> Void = {
    print("testOne")
}
print(testOne())

• 从单表达式闭包隐式返回：单表达式闭包能够通过从它们的声明中删掉 return 关键字来隐式返回它们单个表达式的结果

//删除 return 关键字
let testOne:(String, String) -> String = {s1, s2 in s1 + s2}
print(testOne("test", " one"))

• 简写实际参数名：Swift 自动对行内闭包提供简写实际参数名，可以通过 $0 , $1 , $2 等名字来引用闭包的实际参数值

//通过 $0 , $1 , $2 等名字来引用闭包的实际参数值
let testOne:(String, String) -> String = { $0 + $1 }
print(testOne("test", " one"))

• 运算符函数：Swift 的 String 类型定义了关于大于号( >)的特定字符串实现，让其作为一个有两 个 String 类型形式参数的函数并返回一个 Bool 类型的值

//运算符函数
let names = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var reversedNames = names.sorted(by: > )
print(reversedNames)

• 尾随闭包

1. 当函数的最后一个参数是闭包时，在函数调用时可以把闭包表达式写在()外面
2. 尾随闭包是一个书写在函数括号之后的闭包表达式
3. 如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性

//函数类型作为形式参数类型
func exec(_ mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    mathFunction(a, b)
}
//调用 exec 函数
exec({ num1, num2 in     //给定一个符合函数类型的闭包,可以看作是第一个参数的函数实现
    return num1 + num2
}, a: 3, b: 5)
//这样的函数调用形式看起来很不友好，如果闭包表达式有很多行的话，会更加不友好，不利于代码的阅读。swift提供了一个尾随闭包的概念

//尾随闭包
func exec(a: Int, b: Int, mathFunction: (Int, Int) -> Int) {
    mathFunction(a, b)
}
把闭包表达式写在了函数括号之后，增强了代码的可读性，这就是尾随闭包
//exec(a: 3, b: 5) { (num1, num2) -> Int in
//    return num1 + num2
//}
//尾随闭包可以使用简化参数名，如$0, $1(从0开始，表示第i个参数...)
exec(a: 3, b: 5) { return $0 + $1 }

//如果闭包表达式是函数的唯一实参，而且使用了尾随闭包的语法，可以将函数名后边的圆括号省略
func exec2(mathFunction:(Int, Int) -> Int) {
    print(mathFunction(1, 2))
}
//调用, 将函数名后边的圆括号省略
exec2 { (num1, num2) -> Int in
    return num1 + num2
}

• 逃逸闭包

4. 如果一个闭包被作为一个函数的参数，并且在函数执行完之后才被执行，那么这种情况下的闭包就被称为逃逸闭包
5. 在参数名的:后面用@escaping来修饰说明逃逸闭包
6. 一般在涉及到异步操作时，闭包放在异步线程里，在这种情况下就会出现逃逸闭包，特别是在网络请求时会出现这种情况

//逃逸闭包
func exec(fn: @escaping () -> ()) {
    //延迟 5 秒
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 5) {
        //5 秒后调用闭包
        fn()
    }
    print("函数执行完毕")
}
//调用函数
exec {
    print("闭包执行完毕")
}
//这段代码会先打印"函数执行完毕"，5秒后再执行闭包打印"闭包执行完毕"

• 自动闭包

5. 自动闭包是一种自动创建的用来把作为实际参数传递给函数的表达式打包的闭包
6. 这种闭包不接受任何参数（@autoclosure只支持() -> T格式的参数），当它被调用的时候，会返回被包装在其中的表达式的值
7. 这种便利语法让你能够省略闭包的花括号，用一个普通的表达式来代替显式的闭包
8. 自动闭包允许你延迟处理，因此闭包内部的代码直到你调用它的时候才会运行

//添加 @autoclosure 关键字, 当闭包被调用的时候，会返回被包装在其中的表达式的值
public func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line) {
    if !condition() {
        print(message())
    }
}
let number = 3
assert(number > 3, "number 不大于3")  //输出: number 不大于3

//自动闭包允许延迟处理
var person = ["zhangsan", "lisi", "wangwu", "zhailiu"]
print(person.count)    // 输出: 4
let deletePerson = { person.remove(at: 0) }
print(person.count)   //此时输出还是 4,因为没有调用闭包没有被调用,闭包里的代码没有被执行

//此时调用闭包
print(deletePerson())  //输出 "zhangsan"
print(person.count)    //输出: 3

//闭包作为实际参数传递给函数时,能获得同样的延时求值行为
//闭包作为实参, 可以显示的使用闭包
var person = ["zhangsan", "lisi", "wangwu", "zhailiu"]
func serve(customer customerProvider: () -> String) {
    print("Now serving (customerProvider())!")
}
//函数接受一个返回顾客名字的显式的闭包
serve(customer: { person.remove(at: 0) })  //打印: Now serving zhangsan!

//自动闭包作为实际参数
var person = ["zhangsan", "lisi", "wangwu", "zhailiu"]
//customerProvider 参数将自动转化为一个闭包，因为该参数被标记了 @autoclosure 特性
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving (customerProvider())!")
}
serve(customer: person.remove(at: 0))  //打印: Now serving zhangsan!

• 自动 + 逃逸

//自动闭包允许逃逸,同时使用 @autoclosure 和 @escaping 标志
var customerInLine = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
var customerProviders: [() -> String] = []
func collectionCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
    customerProviders.append(customerProvider)
}
print(customerProviders.count)   //打印: 0
collectionCustomerProviders(customerInLine.remove(at: 0))
collectionCustomerProviders(customerInLine.remove(at: 0))
print(customerInLine.count)   //打印: 4
print(customerProviders.count)  //打印: 2

for c in customerProviders {
    print("Now serving (c())")
}
/*
 Now serving zhangsan
 Now serving lisi
 */

collectCustomerProviders(_ : ) 函数并没有调用传入的 customerProvider 闭包，而是将闭包追加到了 customerProviders 数组中。
这个数组定义在函数作用域范围外，这意味着数组内的闭包能够在函数返回之后被调用。
因此，customerProvider 参数必须允许“逃逸”出函数作用域。

3、闭包捕获值

• 闭包可以对外部函数的变量、常量进行捕获
• 闭包捕获时机是在函数执行完，return时再去捕获
• 当函数里有多个闭包时，只会对变量、常量捕获一次，多个闭包对捕获的变量、常量共享
• 闭包不会对全局变量进行捕获

//Mark:局部变量捕获
typealias fn = (Int) -> ()
func exec() -> fn {
    var num = 0
    return { a in
        num += a
        print(num)
    }
}
let fn1 = exec()
fn1(1)
fn1(2)
fn1(3)

fn1、fn2、fn3输出的结果分别是1、3、6。
这是一个函数中返回了一个闭包，在闭包里对num进行了累加并输出结果。
1、第一次调用fn1时，num为0，0加上参数1=1
2、第二次调用fn1时，闭包里的num的值是第一次fn1里的累加结果1，1加上参数2=3
3、第三次调用fn1时，闭包里num是第二次fn1里累加的结果3，3加上参数3=6
从三次调用fn1来看，闭包里num都是保存了上次调用后num的值，这是因为闭包捕获了外部的num，并重新在堆上分配了内存，当执行let fn1 = exec()时，把闭包的内存地址给了fn1,所以每次调用fn1都是调用的同一块内存，同一个闭包，闭包里有保存中捕获后的num的内存地址，所以每次调用都是同一个num

typealias fn = (Int) -> ()
func exec() -> fn {
    var num = 0
    return { a in
        num += a
        print(num)
    }
}
let fn1 = exec()
fn1(1)   //打印: 1
fn1(2)   //打印: 3

let fn2 = exec()
fn2(3)   //打印: 3
fn2(4)   //打印: 7
//再次调用 fn1,
fn1(3)   //打印: 6

//将上面的代码稍微改一下，将exec分别赋值给 fn1 和 fn2，输出的结果不同。这个为什么不是跟上面一样累加呢，因为exec分别赋值给了fn1 和 fn2，fn1 和 fn2 指向的是两个不一样的地址，当每调用一次exec()函数，num会初始化为0

typealias fn = (Int) -> ()
func exec() -> fn {
    var num = 0
    func plus(a: Int) {  //内嵌函数是特殊闭包,闭包获取局部变量
       num += a
        print(num)
    }
    num = 6
    return plus
}
let fn1 = exec()
fn1(1)    //打印: 7
fn1(2)    //打印: 9
//这还是一个局部变量捕获的问题，闭包会在函数执行完，return的时候才会去捕获num，此时num已经由0变为6，所以执行f1(1)输出结果为7

//当函数里有多个闭包时，只会对变量、常量捕获一次，多个闭包对捕获的变量、常量共享
typealias fn = (Int) -> ()
func exec() -> (fn, fn) {   //函数返回了一个元祖，元祖里是两个闭包，两个闭包里面都调用了num
    var num = 0
    func plus(a: Int) {
        num += a
        print("plus: (num)")
    }
    func minus(a: Int) {
        num -= a
        print("minus: (num)")
    }
    return (plus, minus)
}
let (p, m) = exec()
p(5)     // 5
m(4)     // 1
p(8)     // 9
m(5)     // 4

因为当函数里有多个闭包时，只会对变量、常量捕获一次，多个闭包对捕获的变量、常量共享。在调用m(4)时，前面已经调用过p(5)，此时num已经变为5，所以当调用m(4)，输出结果为1