iOS-swift-关闭包

一. 闭包表达式（Closure Expression）

在Swift中，可以通过func定义一个函数，也可以通过闭包表达式定义一个函数，闭包表达式和闭包是两回事

闭包表达式的格式如下：

{    (参数列表) -> 返回值类型 in    函数体代码}

通过func定义一个函数：

func sum(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }

通过闭包表达式定义一个函数：

//通过闭包表达式定义一个函数，然后调用var fn = {    (v1: Int, v2: Int) -> Int in    return v1 + v2}fn(10, 20)  //闭包调用的时候默认不用写参数名称的 //通过闭包表达式定义一个函数，并且直接调用{(v1: Int, v2: Int) -> Int in    return v1 + v2}(10, 20)

二. 闭包表达式的简写

//传入两个Int变量，返回一个函数func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {    print(fn(v1, v2))}//什么都不省略exec(v1: 10, v2: 20, fn: {    (v1: Int, v2: Int) -> Int in    return v1 + v2})//省略参数类型、返回值类型 (因为编译器能推断出来)exec(v1: 10, v2: 20, fn: {    v1, v2 in return v1 + v2})//省略returnexec(v1: 10, v2: 20, fn: {    v1, v2 in v1 + v2})//超级简写：$0代表第一个参数，$1代表第二个参数exec(v1: 10, v2: 20, fn: { $0 + $1 })//终极简写：只用一个+exec(v1: 10, v2: 20, fn: +)

三. 尾随闭包

如果将一个很长的闭包表达式作为函数的最后一个实参，使用尾随闭包可以增强函数的可读性。
尾随闭包是一个被书写在函数调用括号外面(后面)的闭包表达式。

func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {    print(fn(v1, v2))}//写成尾随闭包，增强函数的可读性exec(v1: 10, v2: 20) {    $0 + $1}

如果闭包表达式是函数的唯一实参，而且使用了尾随闭包的语法，那就不需要在函数名后边写圆括号（因为没其他参数了，肯定可以省略圆括号）

func exec(fn: (Int, Int) -> Int) {    print(fn(1, 2))}exec(fn: { $0 + $1 }) //都不省略exec() { $0 + $1 } //省略标签exec { $0 + $1 } //省略标签和()

忽略参数

func exec(fn: (Int, Int) -> Int) {     print(fn(1, 2)) } //用_忽略参数exec { _,_ in 10 } //10

示例：数组的排序

sort函数要求传入一个(Element, Element) -> Bool类型的参数：

func sort(by areInIncreasingOrder: (Element, Element) -> Bool)

可以传入函数：

// 返回true: i1排在i2前面，返回false: i1排在i2后面func cmp(i1: Int, i2: Int) -> Bool {    // 大的排在前面    return i1 > i2}var nums = [11, 2, 18, 6, 5, 68, 45]nums.sort(by: cmp)// [68, 45, 18, 11, 6, 5, 2]

也可以传入闭包表达式：

nums.sort(by: {    (i1: Int, i2: Int) -> Bool in    return i1 < i2})nums.sort(by: { i1, i2 in return i1 < i2 })nums.sort(by: { i1, i2 in i1 < i2 })nums.sort(by: { $0 < $1 })nums.sort(by: <)nums.sort() { $0 < $1 }nums.sort { $0 < $1 }  //[2, 5, 6, 11, 18, 45, 68]

四. 闭包（Closure）

1. 什么是闭包

网上有各种关于闭包的定义，个人觉得比较严谨的定义是：
一个函数和它所捕获的变量\常量环境组合起来，称为闭包
一般指定义在函数内部的函数
一般它捕获的是外层函数的局部变量\常量

闭包如下：

typealias Fn = (Int) -> Int//func函数加上捕获的num变量组成闭包func getFn() -> Fn {    var num = 0    func plus(_ i: Int) -> Int {        num += i        return num    }    return plus} // 返回的plus和num变量形成了闭包//闭包表达式加上捕获的num组成闭包func getFn() -> Fn {    var num = 0    return {        num += $0        return num    }}    var fn1 = getFn() //想象成创建了一个实例对象var fn2 = getFn() //想象成再创建一个实例对象fn1(1) // 1fn1(3) // 4fn1(5) // 9fn2(2) // 2fn2(4) // 6fn2(6) // 12

解释如上代码：getFn函数调用的时候，getFn函数里面的num是在栈空间，在getFn函数调用完之前会将num变量拷贝到堆空间，返回的plus和堆空间的num变量形成了闭包，所以以后每次调用闭包的时候闭包里面的num变量一直都是刚开始捕获的那个值。(当getFn函数调用完的时候，栈空间的num变量就被销毁了)

可以把闭包想象成是一个类的实例对象：
内存在堆空间
捕获的局部变量\常量就是对象的成员(存储属性)
组成闭包的函数就是类内部定义的方法

类如下：

class Closure {    var num = 0    func plus(_ i: Int) -> Int {        num += i        return num    }}var cs1 = Closure()var cs2 = Closure()cs1.plus(1) // 1cs1.plus(3) // 4cs1.plus(5) // 9 cs2.plus(2) // 2cs2.plus(4) // 6cs2.plus(6) // 12

2. 闭包的本质

typealias Fn = (Int) -> Intfunc getFn() -> Fn {    var num = 0    func plus(_ i: Int) -> Int {        num += i        return num    }    return plus} // 返回的plus和num形成了闭包var fn1 = getFn() //想象成创建了一个实例对象var fn2 = getFn() //想象成再创建一个实例对象fn1(1) // 1fn1(3) // 4fn1(5) // 9fn2(2) // 2fn2(4) // 6fn2(6) // 12print(MemoryLayout.size(ofValue: fn1)) //16print(MemoryLayout.stride(ofValue: fn1)) //16print(MemoryLayout.alignment(ofValue: fn1)) //8

下面结论都是MJ老师通过汇编一步一步验证的：

没捕获

当plus函数没有捕获外面变量，fn1占用16字节，前8字节存放的是plus函数地址，后8字节为空。

全局变量

如果num是全局变量，全局变量不会捕获到堆空间，捕获到堆空间的目的是保住num的命，全局变量在程序运行中一直活着，根本没必要捕获。这时候fn1占用16字节，前8字节存放的是plus函数地址，后8字节为空。

捕获了

① 当plus函数捕获了外面变量，fn1占用16个字节，前8个字节存放的是plus函数地址，后8个字节存放的是堆空间的地址值(堆空间分配24字节，前8字节放类型信息，后8字节放引用计数，最后8字节放num)。
② 执行fn1(1)、fn1(3)...最终会调用plus函数，调用plus函数的时候传入两个参数，一个是i，一个是堆空间的地址值，有了堆空间的地址值就能访问num进行一些运算了。
③ fn2也是16字节，前8字节和fn1前8字节一样的，因为都是plus函数的地址值，但是后8字节和fn1不一样，因为堆空间的内存是重新分配的，所以堆空间的地址值不一样。

问题：如果将上面的num换成Person对象呢？

func testClosure() {    class Person {        var age: Int = 10    }    typealias Fn = (Int) -> Int    func getFn() -> Fn {        // 局部变量，对象类型        var person1 = Person()        var person2 = Person()        func plus(_ i: Int) -> Int {            person1.age += i            person2.age += i            return person1.age + person2.age        }        return plus    } // 返回的plus和num形成了闭包    var fn1 = getFn()    print(fn1(1)) // 22    print(fn1(3)) // 28    var fn2 = getFn()    print(fn2(2)) // 24    print(fn2(4)) // 32}testClosure()

由于我不会看汇编，猜测一下：由于Person对象本来就在堆空间，所以如果plus函数捕获了Person对象，应该是将Person对象的指针保存到闭包里面了，plus函数内部会根据Person对象的修饰符(__strong、__weak、__unsafe_unretained)做出相应的操作，形成强引用(retain)或者弱引用，这样以后如果要使用Person对象，就直接通过闭包里面Person对象的指针访问就可以了。

3. 关于闭包练习

练习①：

typealias Fn = (Int) -> (Int, Int) func getFns() -> (Fn, Fn) {    var num1 = 0    var num2 = 0    func plus(_ i: Int) -> (Int, Int) {        num1 += i        num2 += i << 1 //左移1就是乘以2        return (num1, num2)    }    func minus(_ i: Int) -> (Int, Int) {        num1 -= i        num2 -= i << 1 //左移1就是乘以2        return (num1, num2)     }    return (plus, minus)}let (p, m) = getFns()p(5) // (5, 10)m(4) // (1, 2)p(3) // (4, 8)m(2) // (2, 4)

上面的闭包中有两个变量num1、num2，两个函数plus、minus，现在的问题是两个函数是分别捕获num1、num2还是共同捕获num1、num2。
通过汇编分析可知，调用一次getFns()，num1、num2各分配一次堆空间，然后这两个堆空间给plus、minus函数共享。

其实，如果把闭包当成类就更容易理解了，num1、num2相当于类的成员变量，两个函数相当于类的成员函数，结果是一样的，如下：

class Closure {    var num1 = 0    var num2 = 0    func plus(_ i: Int) -> (Int, Int) {        num1 += i        num2 += i << 1        return (num1, num2)    }    func minus(_ i: Int) -> (Int, Int) {        num1 -= i        num2 -= i << 1        return (num1, num2)     }}var cs = Closure()cs.plus(5) // (5, 10)cs.minus(4) // (1, 2)cs.plus(3) // (4, 8)cs.minus(2) // (2, 4)

练习②：

var functions: [() -> Int] = []for i in 1...3 {    functions.append { i }     //上面是尾随闭包(不接收参数返回i的函数，这个函数作为append的参数)    //和下面注释表示的是一个意思，三个myFunc()函数对应三个i//func myFunc() -> Int {//    return i//}//functions.append(myFunc)for f in functions {    print(f())}// 1// 2// 3

首先要看懂上面的尾随闭包。接下来分析为什么打印：1 2 3
分析汇编可知：上面的i捕获了三次(i == 1,i == 2,i == 3)，各分配一次堆空间，for循环里面的三个“myFunc()函数”分别访问对应的三个堆空间。

如果把上面的闭包想象成类就是下面这样：

class Closure {    var i: Int        init(_ i: Int) {        self.i = i    }        func get() -> Int {        return i    }}var clses: [Closure] = []for i in 1...3 {    clses.append(Closure(i))}for cls in clses {    print(cls.get())}

注意

如果返回值是函数类型，那么参数的修饰要保持统一

func add(_ num: Int) -> (inout Int) -> Void {    func plus(v: inout Int) {        v += num    }    return plus}var num = 5add(20)(&num)print(num)

如上，add函数返回的函数类型要和plus函数的类型保持一致。

五. 自动闭包

为什么使用延迟加载？如下代码：

func getNumber() -> Int {    let a = 10    let b = 11    print("getNumber")    return a + b}func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {    return v1 > 0 ? v1 : v2}getFirstPositive(10, getNumber())

打印：getNumber
上面既然第一个参数传入了10，大于0，那么getNumber()就没必要调用了，但是上面还是调用了，所以可以使用延迟加载减少不必要的调用。

如果我们将第二个参数改成不接收任何参数返回一个Int的函数：

func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int {    return v1 > 0 ? v1 : v2()}//调用getFirstPositive函数getFirstPositive(10, {    let a = 10    let b = 11    print("getNumber")    return a + b})

传入10，打印空
传入-10，打印：getNumber
这样就实现了，需要调用第二个函数的时候才调用第二个函数，不需要的时候就不调用。( 比如一些网络请求啊，如果前面的符合条件就没必要进行请求了)

再看下面代码：

// 如果第1个数大于0，返回第一个数。否则返回第2个数func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {    return v1 > 0 ? v1 : v2}getFirstPositive(10, 20) // 10getFirstPositive(-2, 20) // 20getFirstPositive(0, -4) // -4

// 改成函数类型的参数，可以让v2延迟加载func getFirstPositive1(_ v1: Int, _ v2: () -> Int) -> Int? {    return v1 > 0 ? v1 : v2()}getFirstPositive1(-4) { 20 } //很丑

//改成自动闭包func getFirstPositive2(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int? {    return v1 > 0 ? v1 : v2()}getFirstPositive2(-4, 20) //自动将 20 封装成闭包 { 20 }

由于我们把第二个参数改成了函数，当传入-4，20的时候就是：getFirstPositive(-4) { 20 }，这样写比较丑，所以Swift提供了一种自动闭包的语法糖。

@autoclosure 会自动将 20 封装成闭包 { 20 }
@autoclosure 只支持 () -> T 格式的参数
空合并运算符 ?? 使用了 @autoclosure 技术，源代码如下：

public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?)    rethrows -> T? {  switch optional {  case .some(let value):    return value  case .none:    return try defaultValue()  }}