『闭包』是独立的代码块，可以在你代码中随意传递和使用 。Swift 中的闭包与 Objective-C/C 中的 Block、其他编程语言中的匿名函数相似。

    闭包可以捕获和存储其所在上下文中任意常量和变量的引用。被称为包裹常量和变量。 Swift 会为你管理在捕获过程中涉及到的所有内存操作
    在函数章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
    1、全局函数是一个有名字但不会捕获任何值的闭包
    2、嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
    3、闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
    Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
    1、利用上下文推断参数和返回值类型
    2、隐式返回单表达式闭包，即单表达式闭包可以省略 return 关键字
    3、参数名称缩写
    4、尾随闭包语法

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

闭包表达式

闭包表达式是一种利用简洁语法构建内联闭包的方式。
闭包表达式参数 可以是 in-out 参数，但不能设定默认值。也可以使用具名的可变参数（译者注：但是如果可变参数不放在参数列表的最后一位的话，调用闭包的时时编译器将报错。元组也可以作为参数和返回值。
{
    (parameters) -> returnType in
    statements
}
    
    
//闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。
    reversedNames = names.sorted(by:{
        (s1: String,s2: String) -> Bool in
        return s1 > s2
    })
    // 凶残的苹果对闭包的表达式进行了一轮又一轮的简化, 直达之前提过的最简表达式
    // 第一轮:
    reversedNames = names.sorted(by:{(s1: String,s2: String) -> Bool in return s1 > s2}) // 太短可一行
    // 第二轮:
    reversedNames = names.sorted(by:{s1,s2 in return s1 > s2})// 根据上下文判断类型
    // 第三轮:
    reversedNames = names.sorted(by:{s1,s2 in s1 > s2}) // 排序需要一个Bool值, 那么s1>s2这个表达式符合需求 省略return
    // 第四轮:
    reversedNames = names.sorted(by:{$0 > $1}) // 知道会有2个参数, 入参的写法免了
    // 第五轮:
    reversedNames = names.sorted(by:>) // 完全交给编译器来推导..

尾随闭包

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

    func someFunctionThatTakeAClosures(closure:()->Void){
        //函数体
    }
    //不使用尾随闭包
    someFunctionThatTakeAClosures(closure: {
        // 闭包主体部分
    })
    //使用尾随闭包
    someFunctionThatTakeAClosures() {
        //使用尾随闭包
    }
    //只有一个闭包作为参数，括号可以省略
    someFunctionThatTakeAClosures{
        
    }
    //排序方法还可以简化
    reversedNames = names.sorted(){$0 > $1} //第六轮
    //再凶残一点
    reversedNames = names.sorted {$0 > $1} //第七轮
    
    //当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。举例来说，Swift 的 Array 类型有一个 map(_:) 方法
    //这个方法获取一个闭包表达式作为其唯一参数。该闭包函数会为数组中的每一个元素调用一次，并返回该元素所映射的值。
    //具体的映射方式和返回值类型由闭包来指定。
    //当提供给数组的闭包应用于每个数组元素后，map(_:) 方法将返回一个新的数组，数组中包含了与原数组中的元素一一对应的映射后的值。
 
    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 strings = numbers.map { (number) -> String in
        var number = number
        var output = ""
        repeat {
            output = digitNames[number % 10]! + output //取余数
            number /= 10
        }while number > 0
        return output
    }
    //print(strings)
    // strings 常量被推断为字符串类型数组，即 [String]

值捕获

闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值
Swift 中，可以捕获值的闭包的最简单形式是嵌套函数，也就是定义在其他函数的函数体内的函数。
嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。

    func makeIncrementer(forIncrement amount: Int)->()->Int{
        var runningTotal = 0
        func incrementer() -> Int{
            runningTotal += amount
            return runningTotal
        }
        return incrementer
    }
    //makeIncrementor 返回类型为 () -> Int。这意味着其返回的是一个函数，而非一个简单类型的值
    //该函数在每次调用时不接受参数，只返回一个 Int 类型的值
    /*
     incrementer() 函数并没有任何参数，但是在函数体内访问了 runningTotal 和 amount 变量。
     这是因为它从外围函数捕获了 runningTotal 和 amount 变量的引用。
     捕获引用保证了 runningTotal 和 amount 变量在调用完 makeIncrementer 后不会消失，并且保证了在下一次执行 incrementer 函数时，runningTotal 依旧存在。
     注意：为了优化，如果一个值不会被闭包改变，或者在闭包创建后不会改变，Swift 可能会改为捕获并保存一份对值的拷贝。 Swift 也会负责被捕获变量的所有内存管理工作，包括释放不再需要的变量。
    */
    let incrementByTen = makeIncrementer(forIncrement: 10)
    //print(incrementByTen())
    //返回10
    //print(incrementByTen())
    //返回20
    //print(incrementByTen())
    //返回30
    
    //如果你创建了另一个 incrementor，它会有属于自己的引用，指向一个全新、独立的 runningTotal 变量：
    
    let incrementBySeven = makeIncrementer(forIncrement: 7)
    //print(incrementBySeven())
    // 返回的值为7
    //再次调用原来的 incrementByTen 会继续增加它自己的 runningTotal 变量，该变量和 incrementBySeven 中捕获的变量没有任何联系：
    
    //print(incrementByTen())
    // 返回的值为40”
    //注：捕获会引起循环引用

闭包是引用类型

上面的例子中，incrementBySeven 和 incrementByTen 都是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量的值。这是因为函数和闭包都是引用类型。
无论你将函数或闭包赋值给一个常量还是变量，你实际上都是将常量或变量的值设置为对应函数或闭包的引用

    let alsoIncrementByTen = incrementByTen
    alsoIncrementByTen()

逃逸闭包

当一个闭包作为参数传递给函数时，有种情况是不能立即被调用，而是储存在函数外定义的变量中。函数在启动操作之后就已经返回，但在操作完成之后才调用闭包 —— 这种闭包就需要需要逃逸，以便函数返回后调用。
当您声明将闭包作为参数之一的函数时，可以在参数的类型之前写入 @ escape，用来表示允许闭包逃逸。

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

自动闭包

自动闭包 自动包装书写的表达式，并将表达式作为一个闭包传入的函数。自动闭包不包含任何参数，当它被调用时会返回一个内部表达式包装的值。这种写法让你使用正常表达式而不是闭包的语法使你可以省略函数旁边的大括号。

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())!")
// 打印 "Now serving Chris!"
print(customersInLine.count)
// 打印 "4"

// customersInLine 数组是 ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } )
// 输出 "Now serving Alex!"

上面代码中的 serve(customer:) 函数接受一个返回顾客姓名的显示闭包。下面这个版本的 serve(customer:) 完成同样的功能，不过它并没有接受一个显示闭包，而是接受一个自动闭包，使用 @autoclosure 关键字标记参数。现在你可以将这个函数当作一个接受 String 类型的参数的函数而不是一个闭包一样调用。这个参数会自动转换成一个闭包，因为参数 customerProvider 的类型被标记成 @autoclosure 属性。

//  customersInLine 数组是 ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
// 输出 "Now serving Ewa!"

注：自动闭包使用过多会让你的代码很难阅读。 函数和上下文应该明确表明代码被延迟执行。