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
})

//省略return
exec(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) // 1
fn1(3) // 4
fn1(5) // 9
fn2(2) // 2
fn2(4) // 6
fn2(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) // 1
cs1.plus(3) // 4
cs1.plus(5) // 9 
cs2.plus(2) // 2
cs2.plus(4) // 6
cs2.plus(6) // 12

2. 闭包的本质

typealias Fn = (Int) -> Int

func 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) // 1
fn1(3) // 4
fn1(5) // 9
fn2(2) // 2
fn2(4) // 6
fn2(6) // 12
print(MemoryLayout.size(ofValue: fn1)) //16
print(MemoryLayout.stride(ofValue: fn1)) //16
print(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 = 5
add(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) // 10
getFirstPositive(-2, 20) // 20
getFirstPositive(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()
  }
}

iOS-swift-关闭包

一. 闭包表达式（Closure Expression）

二. 闭包表达式的简写

三. 尾随闭包

四. 闭包（Closure）

1. 什么是闭包

2. 闭包的本质

3. 关于闭包练习

五. 自动闭包

推荐

点击进群

评论

发表回复取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

iOS-swift-关闭包

一. 闭包表达式（Closure Expression）

二. 闭包表达式的简写

三. 尾随闭包

四. 闭包（Closure）

1. 什么是闭包

2. 闭包的本质

3. 关于闭包练习

五. 自动闭包

推荐

点击进群

评论

发表回复 取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

发表回复取消回复