前言

Swift中的闭包跟OC中的代码块(Block)比较相似，下面学习一下。

1.闭包表达式

• sort方法
  sort方法能根据提供的闭包函数将已知类型数组中的值进行排序，排序后原数组不会被修改。

   let names =["Chris", "Alex", "Ewa", "Barry", "Daniella"]
   func backwards(s1:String, s2:String) -> Bool{
              return s1 > s2
    }
    var reve =names.sort(backwards)
    // reve 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
  

上面这些代码本质上只是写了一个单表达式(a>b),接下来我们利用闭包表达式来构造一个内联排序闭包

    语法：
    {    (prameters) -> returnType in
            statements
    }

上面例子的修改(内联闭包)

    reve = names.sort({(s1: String, s2:String) -> Bool in
        return s1 >s2
    })

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

    reve = names.sort({s1,s2 in return s1 > s2})
  

• 单表达式闭包隐式返回
  单行表达式闭包可以通过省略return关键字来隐式返回单行表达式的结果：

    reve = names.sort({s1,s2 in  s1 > s2})
    这个例子，明确表示需要返回`Bool`类型的值，因为只包含单一表达式`s1>s2`。
  

• 参数名称缩写
  可直接用$0,$1,$2来顺序调用闭包的参数，

    reve = names.sort({$0>$1})
    $0,$1表示闭包中第一个和第二个`String`类型的参数
  

• 运算符函数
  实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。Swift 的String类型定义了关于大于号>的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值。而这正好与sort(_:)方法的参数需要的函数类型相符合。因此，您可以简单地传递一个大于号，Swift 可以自动推断出您想使用大于号的字符串函数实现：

    reve = names.sort(>)
  

2.尾随闭包

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

    func some(close: ()->Void){
            函数体部分
    }

    //不使用尾随闭包
    some({
            //闭包主体部分
    })

    //使用尾随闭包
    some(){
            //闭包主体部分
    }

例子：

     reve = names.sort({$0>$1})
     可以改写为
    reve = names.sort(){$0>$1}    

如果函数只需要一个闭包表达式一个参数，可以省略():

    reve = names.sort {$0>$1}

4.捕获值

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

举个例子，这有一个叫做makeIncrementor的函数，其包含了一个叫做increment or的嵌套函数。嵌套函数incrementor()从上下文中捕获了两个值，runningTotal和amount。捕获这些值之后，makeIncrementor将increment or作为闭包返回。每次调用increment or时，其会以amount作为增量增加runningTotal的值。

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

makeIncrementor 函数的返回值类型为()->Int,即incrementor,　
定义了一个runningTotal的变量，incrementor函数内部捕获外部变量。

注意:为了优化，如果一个值是不可变的，Swift 可能会改为捕获并保存一份对值的拷贝。
Swift 也会负责被捕获变量的所有内存管理工作，包括释放不再需要的变量。

    let incrementByTen = makeIncrementor(forIncrement: 10)

    调用
    incrementByTen()
    // 返回的值为10
    incrementByTen()
    // 返回的值为20
    incrementByTen()
    // 返回的值为30
    由此可见，每次运行之后，函数对值的改变是有效的并且持续的。

如果创建一个新的incrementor,便会有全新的独立的runningTotal变量引用：

    let incrementBySeven = makeIncrementor(forIncrement: 7)
    incrementBySeven()
    // 返回的值为7

再次调用incrementByTen()会在原来变量上继续增加

    incrementByTen()
    // 返回的值为40

注意：如果您将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，您将创建一个在闭包和该实例间的循环强引用。Swift 使用捕获列表来打破这种循环强引用。

5.闭包是引用类型

将闭包赋值给两个不同的变量货常量，实际上两个值是指向同一个闭包

6.非逃逸闭包

当一个闭包作为参数传到函数中，但是这个闭包在函数返回之后才被执行，称之为逃逸函数.可以在闭包前加上@noescape,指明不允许逃逸闭包，能使编译器知道这个闭包的生命周期，闭包只能在函数体中被执行，不能脱离函数体执行，所以编译器明确知道运行时的上下文。

一种能使闭包“逃逸”出函数的方法是，将这个闭包保存在一个函数外部定义的变量中。举个例子，很多启动异步操作的函数接受一个闭包参数作为 completion handler。这类函数会在异步操作开始之后立刻返回，但是闭包直到异步操作结束后才会被调用。在这种情况下，闭包需要“逃逸”出函数，因为闭包需要在函数返回之后被调用。例如：、

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

注意：将闭包标注为@noescape使你能在闭包中隐式地引用self。

7.自动闭包

闭包