闭包

闭包是自包含的函数代码块，可以在代码中被传递和使用。Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的匿名函数（Lambdas）比较相似。
闭包可以捕获和存储其所在上下文中任意常量和变量的引用。被称为包裹常量和变量。 Swift 会为你管理在捕获过程中涉及到的所有内存操作。

/*
 Closures定义一个闭包变量
 */
var Closures: (Int,Int) -> Void
/*
 实现闭包处理业务逻辑
 */
Closures = { i,s in
    print(i,s)
}
/*
 调用闭包
 */
Closures(4,5)
/*
 staticClosures定义一个闭包常量
 */
let staticClosures = { (i: Int,s:Int) in
    print(i,s)
}
/*
 调用闭包
 */
staticClosures(1,2)

/*
 在方法中使用闭包，以下是无参数尾随闭包的使用方法
 */
func closuresInFunc(value: (Int,Int) -> Void) {
    value(100,200)
}
/*
 在方法中使用闭包，以下是带参数尾随闭包的使用方法，尾随闭包适合那种既调既用的方法需求，既调用方法后，马上需要返回结果的这种
 */
func closuresInFunc2(numb: Int,value: (Int,Int) -> Void) {
    value(100 + numb,200 + numb)
}
/*
 调用无参数方法
 */
closuresInFunc { (i, s) in
    print(i,s)
}
/*
 调用参数方法
 */
closuresInFunc2(numb: 9) { (i, s) in
    print(i,s)
}
/*
 值捕获，即使定义这些常量和变量的原作用域已经不存在，
 闭包仍然可以在闭包函数体内引用和修改这些值,
 同时也可以理解为将闭包作为返回值
 **/
func closuresToReturn(num: Int) -> () ->Int {
    var n = 0
    func returnValue() -> Int {
        n = n+num
        return n
    }
    return returnValue
}
/*
 值捕获，需要指定一个返回接收者，
 这样通过接收者（常量或变量）调用闭包，
 可理解为这个接收者（常量或变量）实际就是用来保持这个值捕获的承接上下文的关键
 该常量指向一个每次调用会将其 runningTotal 变量增加 10 的 returnValue 函数
 **/
let cR = closuresToReturn(num: 10)
/*
 值捕获，使用接收的常量进行调用返回的闭包
 **/
print(cR())///打印结果："10\n"
print(cR())///打印结果："20\n"
/*
 值捕获，未指定接收者，持续调用，不会改变返回值
 **/
closuresToReturn(num: 10)()
closuresToReturn(num: 10)()
/*
 闭包是引用类型,如下，把cR 赋值给c1,c2，然后再去分别调用返回的闭包，
 **/
let c1 = cR
let c2 = cR

print(c2())///打印结果："30\n"
print(c1())///打印结果："40\n"
print(cR())///打印结果："50\n"

/*
 逃逸闭包,当一个闭包作为参数传到一个函数中，
 但是这个闭包在函数返回之后才被执行，
 我们称该闭包从函数中逃逸。
 当你定义接受闭包作为参数的函数时，
 你可以在参数名之前标注 @escaping，
 用来指明这个闭包是允许“逃逸”出这个函数的。
 将一个闭包标记为 @escaping 意味着你必须在闭包中显式地引用 self。
 最常用的地方就是异步的网络请求。
 **/
func afterClosures(n: Int,closures: @escaping () -> Void) {
    let q = DispatchQueue(label: "after")
    print("开始时间： \(Date())")
    q.asyncAfter(deadline: .now() + 5) {
        closures()
    }
}

afterClosures(n: 10) {
    print("结束时间： \(Date())")
}