Swift学习(六:闭包)

前言

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()从上下文中捕获了两个值,runningTotalamount。捕获这些值之后,makeIncrementorincrement 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.自动闭包

闭包

推荐阅读更多精彩内容