iOS-swift-关闭包

59次阅读

共计 6577 个字符，预计需要花费 17 分钟才能阅读完成。

一. 闭包表达式（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()}
}

推荐

面试题持续更新记得关注我哦！
不同的圈子就有不同的学习方式；
（qq 群搜索）：651612063 群密码：111 进群文件可以直接获取大厂面试题

点击进群

正文完
ios
发表至： ios
2020-06-02
 0
关于ios:Swift-类构造器的使用
关于ios:iOS开发面试只需知道这些技术基本通关RunLoop篇
关于ios:iOS签名校验那些事儿
关于ios:UIButton-禁用高亮