swift简单总结（十七）—— 闭包（Closures）

版本记录

版本号	时间
V1.0	2017.07.27

前言

我是swift2.0的时候开始接触的，记得那时候还不是很稳定，公司的项目也都是用oc做的，并不对swift很重视，我自己学了一段时间，到现在swift3.0+已经出来了，自己平时也不写，忘记的也差不多了，正好项目这段时间已经上线了，不是很忙，我就可以每天总结一点了，希望对自己对大家有所帮助。在总结的时候我会对比oc进行说明，有代码的我会给出相关比对代码。
1. swift简单总结（一）—— 数据简单值和类型转换
2. swift简单总结（二）—— 简单值和控制流
3. swift简单总结（三）—— 循环控制和函数
4. swift简单总结（四）—— 函数和类
5. swift简单总结（五）—— 枚举和结构体
6. swift简单总结（六）—— 协议扩展与泛型
7. swift简单总结（七）—— 数据类型
8. swift简单总结（八）—— 别名、布尔值与元组
9. swift简单总结（九）—— 可选值和断言
10. swift简单总结（十）—— 运算符
11. swift简单总结（十一）—— 字符串和字符
12. swift简单总结（十二）—— 集合类型之数组
13. swift简单总结（十三）—— 集合类型之字典
14. swift简单总结（十四）—— 控制流
15. swift简单总结（十五）—— 控制转移语句
16. swift简单总结（十六）—— 函数

闭包

闭包这一概念是OC中没有的，大家可能觉得很陌生，其实你可以把闭包看做OC中的block。

闭包是自包含的函数代码块，可以在代码中被传递和使用，闭包可以捕获和存储上下文中任意常量和变量的引用，这个就是所谓的闭包并包裹着这些常量和变量，俗称闭包。

在前一篇函数部分介绍的全局和嵌套函数实际上也就是特殊的闭包，闭包采取下面三种形式之一：

• 全局函数是一个有名字但不会捕获任何值的闭包
• 嵌套函数是一个有名字并可以捕获其封闭函数阈内值的闭包
• 闭包表达式是一个利用轻量级语法所写的可以捕获上下文中变量或者常量值的匿名闭包。

swift中闭包表达式具有简约的风格，主要优化如下：

• 利用上下文推断参数和返回值类型
• 隐式返回单表达式闭包，即单表达式闭包可以省略return关键字
• 参数名称缩写
• 尾随（Trailing）闭包语法。

下面主要从四个方面介绍闭包。

• 闭包表达式 Closure Expressions
• 尾随闭包 Trailing Closures
• 值捕获 Capturing Values
• 闭包是引用类型 Closures Are Reference Types

---

闭包表达式 - Closure Expressions

嵌套函数是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式，闭包表达式是一种利用简洁语法构建内联闭包的方式，下面我们往下看。

1. 闭包表达式语法 - Closures Expression Syntax

闭包表达式的语法一般如下所示：

{  (parameters) -> returnType in
    statements
}

闭包表达式语法可以使用常量、变量和inout类型作为参数，不提供默认值，也可以在参数列表的最后使用可变参数，元组也可以作为参数和返回值。

下面在给一个例子

let reversed = sorted(names , {(s1 : String, s2 : String)  -> Bool in 
      return s1 > s2
})

闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始，上面的闭包函数体部分可以改写成一行代码。

let reversed = sorted(names , {( s1 : String, s2 : String)  -> Bool in  return s1 > s2 })

2. 根据上下文推端类型 - Inferring Type From Context

实际上，上面的String,String和Bool类型并不需要作为闭包表达式定义中的一部分，因为所有的类型都可以被正确推断，所以可以简化成下面：

let reversed = sorted(names , { s1 , s2  in  return s1 > s2 })

实际上，任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，意味着你几乎不需要利用完整格式构造任何内联闭包。

3. 单表达式闭包隐式返回 - Implicit Return From Single-Expression Clossures

单行表达式闭包可以隐藏return关键字隐式的返回单行结果，所以上面表达式可写作：

let reversed = sorted(names , { s1 , s2  in  s1 > s2 })

4. 参数名称缩写 - Shorthand Argument Names

swift自动为内联函数提供了参数名称缩写功能，你可以直接通过$0、$1、$2来顺序调用闭包的参数。如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断，in关键字也同样可省略，因为此时闭包表达式完全由闭包函数体构成。

let reversed = sorted(names , { $0 > $1 })

在这里，$0和$1表示闭包中第一个和第二个String类型的参数。

5. 运算符函数 - Operator Functions

swift的String类型定义了关于大于号>的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值，这正好与sorted函数的第二个参数需要的函数类型相符合，因此，您可以简单地传递一个大于号，swift可以自动推断出您想使用大于号的字符串函数实现。

let reversed = sorted(names ,  > )

---

尾随闭包 - Trailing Closures

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

func someFunctionThatTakesAClosure(closure : ()  -> ()){
      //函数体部分
}

//下面是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure（{
    //闭包主体部分
}）

下面我们看一下尾随闭包的情况

someFunctionThatTakesAClosure(){
      //闭包主体部分
}

如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把()省略。所以前面的例子可以写成

let reversed = sorted(names ){ $0 > $1 }

当闭包非常长以至于不能再一行中书写的时候，尾随闭包就显得很有用，举个例子，Array类型有一个map方法，其获取一个闭包表达式作为其唯一参数，数值中的每一个元素调用一次该闭包函数，并返回该元素所映射的值。看下面例子。

class JJSwiftVC: UIViewController
{
    override func viewDidLoad()
    {
        super.viewDidLoad()
        
        view.backgroundColor = UIColor.lightGray
        
        let digitalNames = [0 : "Zero", 1 : "One", 2 : "Two", 3 : "Three", 4 : "Four", 5 : "Five", 6 : "Six", 7 : "Seven", 8 : "Eight", 9 : "Nine"]
        let numbers = [12, 34, 53]
        
        let strings = numbers.map { (number) -> String in
            var output = ""
            output = digitalNames[number % 10]!
            print(output)
            return output
        }
        
    }
}

下面看输出结果

Two
Four
Three

---

值捕获 - Capturing Values

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

看下面一段代码

class JJSwiftVC: UIViewController
{

    override func viewDidLoad()
    {
        super.viewDidLoad()
        
        view.backgroundColor = UIColor.lightGray
        
        let incrementValue = makeIncement(forIncrement: 10)
        var value = incrementValue()
        print(value)
        value = incrementValue()
        print(value)
        value = incrementValue()
        print(value)
    }
    
    func makeIncement(forIncrement amount : Int) -> () -> Int{
        var total = 0
        func incrementor() -> Int {
            total += amount
            return total
        }
        return incrementor
    }
    
}

下面看输出结果

10
20
30

上面的例子中，函数makeIncement，其中包含了函数incrementor嵌套，嵌套函数incrementor从上下文中捕获两个值，total和amount，之后，makeIncement将incrementor作为闭包返回，后面每次调用incrementor的时候，其会以amount作为增量增加total的值。这里就是捕获。

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

---

闭包是引用类型 - Closures Are Reference Types

上面的例子中，value是变量，但是该量指向的闭包仍然可以增加其捕获的变量值，这是因为函数和闭包都是引用类型，无论您将函数或者闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用，而非闭包内容本身，也就意味着如果您将闭包赋值给两个不同的变量或者常量，两个值都会指向同一个闭包。

下面看代码，我又增加了三句。

class JJSwiftVC: UIViewController
{

    override func viewDidLoad()
    {
        super.viewDidLoad()
        
        view.backgroundColor = UIColor.lightGray
        
        let incrementValue = makeIncement(forIncrement: 10)
        var value = incrementValue()
        print(value)
        value = incrementValue()
        print(value)
        value = incrementValue()
        print(value)
        
        //这几句是后加的
        let increase = incrementValue
        let value1 = increase()
        print(value1)
    }
    
    func makeIncement(forIncrement amount : Int) -> () -> Int{
        var total = 0
        func incrementor() -> Int {
            total += amount
            return total
        }
        return incrementor
    }
    
}

下面看输出结果

10
20
30
40

可见，值依然增加了10，所以闭包是引用类型。

后记

未完，待续~~~~

秋