swift学习之闭包（closure）

标签：swift

  swift的闭包和c，oc中block是差不多的，其实swift中的全局和嵌套函数实际上也是一种特殊的闭包，闭包有三种形式：

（1）全局函数是有一个名字，但不能捕获任何值的闭包

（2）嵌套函数是有一个名字，可以捕获在函数内的值得闭包

（3）闭包表达式是一个轻量级的语法，可以从上下文中捕获值

闭包表达是一个干净，清晰，鼓励简介，优化的语法，优化包括：

（1）从上下文中推断参数和返回类型

（2）简单的闭包表达可以省略return

（3）简写参数名

（4）尾部闭包语法

（一）闭包表达

闭包表达就是以一个简明准确的方式写一个内联包

（二）sort函数

swift标准库提供了sort函数，用来排序已知类型的数组，通过你提供的排序包规则输出

        let originalNames = ["Chris","Alex","Ewa","Barry","Daniella"]
        var currentNames = originalNames.sort(backwards)

    func backwards(s1: String , s2: String) -> Bool {
        return s1 > s2
    }

下面用闭包表达一下

        var reverse = originalNames.sort({ (s1: String , s2: String) -> Bool in
            
            return s1 > s2
            
        })

           （2）in后面是实现部分

           （3）整个表达式用{}号括起来

由于swift有推断类型功能，闭包可以从上下文推断类型，所以上面的表达式还可以写成：

        var reverse = originalNames.sort({s1 , s2 in return s1 > s2})
        print(reverse)

        var reverse = originalNames.sort({s1 , s2 in s1 > s2})
        print(reverse)

（三）简写参数名

swift对于内联包自动提供了参数名的简写，这些简写名用来关联参数，那么这些看不到简写名是怎么简写的呢？就是$0,$1,$2....

如果你写闭包表达用了简写名，那你写的所有参数就可以省了，因为人家已经相当于给你提供了参数，只是简写了，就不用你写了，写了都TM浪费感情啊，不光浪费自己的，还浪费swift的，尤其是人家程序员的，我都把闭包简成这样了，你就不要写那么麻烦添乱了，省的大家都心里堵得慌，废话不多说了，下面检测一下这个简写：

        var reverse = originalNames.sort( { $0 > $1 } )
        print(reverse)

（四）操作符（有的也叫运算符）函数

由于swift的String类型有规定两个字符的比较，并且返回的是Bool类型，所以上面我们可以写的再简单点，直接传一个操作符（运算符），swift就会自己推断调用string自身规定的实现

         var reverse = originalNames.sort(>)

  意思就是把闭包实现放在尾部来写，为什么要放在尾部呢，因为闭包实现太长了，可能会影响代码的可读性，美观性，所以就放在最后面实现好了

swift数组有一个map（映射）方法，仅仅是采用闭包表达作为参数像里面传递的。这个闭包会遍历数组的每个元素，并且返回相应的可选类型的映射。映射的核心和返回值的类型都是又闭包规定的。当使用map方法后，会返回一个新的数组， 这个数组包含了所有新的映射的值，下面举一个例子（把Int型数组转换成Strin型的数组）说明一下：

        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() {
            (var number) -> String in
            var output = ""
            while number > 0 {
                output = digitNames[number % 10]! + output
                number /= 10
            }
            return output
        }
        
        print(strings)

          其次，通过return，swift已经推断strings是一个字符串型的数组了

         最后，就看打印结果了

如果闭包是函数的唯一参数，函数后面的括号可以省略,所以上面的函数还可以这么写：

        let strings2 = numbers.map {
            (var number) -> String in
            var output = ""
            while number > 0 {
                output = digitNames[number % 10]! + output
                number /= 10
            }
            return output
        }
        
        print(strings2)

规定的返回类型是String类型，存储在返回的数组中了

注意：上面字典后面跟了一个感叹号，因为字典下标语法总是返回一个可选值的如果查询失败的话，但是在上面的例子中，一定要确保字典下标值是有效地，因此我们要强制拆包，得到存储在可选返回值的中的String类型值

（六）值捕获

说白了，就是闭包可以从上下文中捕获值，用为己用（变量常量都可以，还可以自己改变其值），下面举一个简单的函数嵌套的例子

        let incrementByTen = makeIncrementer(forIncrement: 10)
        print(incrementByTen())
    }

    func makeIncrementer(forIncrement amout: Int) -> Void -> Int {
        
        var runningTotal = 0
        
        func increment() -> Int {
            runningTotal += amout
            return runningTotal
        }
        
        return increment
    
    }

        let incrementByTen = makeIncrementer(forIncrement: 10)
        incrementByTen()
        incrementByTen()
        print(incrementByTen())

        let incrementBySeven = makeIncrementer(forIncrement: 7)
        incrementByTen()
        print(incrementByTen())
        print(incrementBySeven())

注意：如果我们把一个闭包定义成了类实例的属性，通过引用这个实例或者它的成员，会产生一个强引用，不过给了我们解决办法，这个我会在后面学习之后进行讲解，谢谢

（七）闭包是引用类型

在上面的例子中，incrementByTen和incrementBySeven是常量，但是他们引用的闭包仍然可以改变runningTotal的值，这是因为函数和闭包都是引用类型的，当我们把函数或者闭包赋给一个常量或者变量时，实际上是我们用这个常量或者变量引用那个闭包，打印里面调用了也算也用，在打印下面的代码中runningTotal的值已经被+10了，

        let alsoIncrementByTen = incrementByTen

好啦，闭包也讲完了，下次我会介绍swift中的枚举

swift学习之闭包（closure）

标签：swift

原文地址：http://blog.csdn.net/rainshenji/article/details/47204077