Swift 進階（五）閉包

閉包運算式（Closure Expression）

在Swift中，可以通過func定義一個函式，也可以通過閉包運算式定義一個函式

閉包運算式格式如下

{
    (引數串列) -> 回傳值型別 in
    函式體代碼
}

var fn = {
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}

{
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}(10, 20)

閉包運算式的簡寫如下

var fn = {
    (v1: Int, v2: Int) -> Int in
    return v1 + v2
}

var fn: (Int, Int) -> Int = { $0 + $1 }

func exec(v1: Int, v2: Int, fn: (Int, Int) -> Int) {
    print(fn(v1, v2))
}


exec(v1: 10, v2: 20) {
    (v1, v2) -> Int in
    return v1 + v2
}

exec(v1: 10, v2: 20, fn: {
    (v1, v2) -> Int in
    return v1 + v2
})

exec(v1: 10, v2: 20, fn: {
    (v1, v2) -> Int in
    v1 + v2
})

exec(v1: 10, v2: 20, fn: {
    v1, v2 in return v1 + v2
})

exec(v1: 10, v2: 20, fn: {
    v1, v2 in v1 + v2
})

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 }
exec { _, _ in 10 }

Swift中的sort函式用來排序的，使用的就是閉包的寫法

var nums = [11, 2, 18, 6, 5, 68, 45]

nums.sort()

nums.sort {
    (i1, i2) -> Bool in
    i1 < i2
}

nums.sort(by: { (i1, i2) 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 }


print(nums) // [2, 5, 6, 11, 18, 45, 68]

閉包（Closure）

一個函式和它所捕獲的變數\常量環境組合起來，稱為閉包

• 一般指定義在函式內部的函式
• 一般它捕獲的是外層函式的區域變數\常量

typealias Fn = (Int) -> Int

func getFn() -> Fn {
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
}

func getFn() -> Fn {
    var num = 0
    return {
        num += $0
        return num
    }
}

通過匯編分析閉包的實作

看下面示例代碼，分別列印為多少

func getFn() -> Fn {
    var num = 0
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
}

var fn = getFn()

print(fn(1)) // 1
print(fn(2)) // 3
print(fn(3)) // 6
print(fn(4)) // 10

我們通過反匯編來觀察

通過這句呼叫可以看出，在return plus之前，閉包底層會呼叫malloc函式進行堆記憶體的分配，也就是將拷貝num的值到堆上來持有不被釋放，而堆疊里的num由于getFn呼叫完畢就隨著堆疊釋放了，plus函式里操作的都是堆上的num

呼叫malloc函式之前需要告訴系統要分配多少記憶體，需要24個位元組來存盤記憶體，而malloc函式分配的都是16的倍數，所以會分配32個位元組記憶體

我們列印rax暫存器的值可以知道，系統分配的32個位元組，前16個位元組用來存盤其他資訊，而且從圖上的圈起來的地方也可以看到，將0移動16個位元組，所以16個位元組之后的8個位元組才用來存盤num的值

呼叫fn(1)，將斷點打在這里，然后查看反匯編指令

然后呼叫到plus函式內部，再次列印rax暫存器的值，發現num的值已經變為1了

然后繼續往下執行呼叫fn(2)，發現num的值已經變為3了

然后繼續往下執行呼叫fn(3)，發現num的值已經變為6了

然后繼續往下執行呼叫fn(4)，發現num的值已經變為10了

閉包和類的相似之處

我們可以把閉包想像成是一個類的實體物件

• 記憶體在堆空間
• 捕獲的區域變數\常量就是物件的成員（存盤屬性）
• 組成閉包的函式就是類內部定義的方法

類似如下示例

class Closure {
    var num = 0
    
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
}

var cs = Closure()
cs.plus(1)
cs.plus(2)
cs.plus(3)
cs.plus(4)

而且通過反匯編也能看出類和閉包的共同之處，分配的堆記憶體空間前16個位元組都是用來存盤基礎資訊和參考計數的

再看下面的示例

如果把num變成全域變數呢，還會不會分配堆記憶體

typealias Fn = (Int) -> Int

var num = 0

func getFn() -> Fn {

    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
}

var fn = getFn()

print(fn(1)) // 1
print(fn(2)) // 3
print(fn(3)) // 6
print(fn(4)) // 10

我們通過反匯編可以看到，系統不再分配堆記憶體空間了

注意：如果回傳值是函式型別，那么引數的修飾要保持統一

func add(_ num: Int) -> (inout Int) -> Void {
    func plus(v: inout Int) {
        v += num
    }
    
    return plus
}

var num = 5
add(20)(&num)

print(num)

自動閉包

我們先看下面的示例代碼

如果呼叫getFirstPositive并傳入兩個引數，第一個引數符合條件，但是還需要呼叫plus來得到第二個引數，這種設計相比就稍許有些浪費了

func getFirstPositive(_ v1: Int, _ v2: Int) -> Int {
    v1 > 0 ? v1 : v2
}

func plus(_ num1: Int, _ num2: Int) -> Int {
    print("haha")
    return num1 + num2
}

getFirstPositive(10, plus(2, 4))

我們進行了一些優化，將第二個引數的型別變為函式，只有條件成立的時候才會去呼叫

func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int {
    v1 > 0 ? v1 : v2()
}

func plus(_ num1: Int, _ num2: Int) -> Int {
    print("haha")
    return num1 + num2
}

getFirstPositive(10, { plus(2, 4)} )

這樣確定能夠滿足條件避免多余的呼叫，但是可讀性就會差一些

我們可以使用自動閉包@autoclosure來修飾形參

@autoclosure會將傳進來的型別包裝成閉包運算式，這是編譯器特性

@autoclosure只支持() -> T格式的引數

func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int {
    v1 > 0 ? v1 : v2()
}

func plus(_ num1: Int, _ num2: Int) -> Int {
    print("haha")
    return num1 + num2
}

getFirstPositive(10, plus(2, 4))

@autoclosure并非只支持最后一個引數

func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int, _ v3: Int) -> Int {
    v1 > 0 ? v1 : v2()
}

空合并運算子??中就使用了@autoclosure來將??后面的引數進行了包裝

有@autoclosure和無@autoclosure會構成函式多載，不會報錯

func getFirstPositive(_ v1: Int, _ v2: () -> Int) -> Int {
    v1 > 0 ? v1 : v2()
}

func getFirstPositive(_ v1: Int, _ v2: @autoclosure () -> Int) -> Int {
    v1 > 0 ? v1 : v2()
}

注意：為了避免與期望沖突，使用了@autoclosure的地方最好明確注釋清楚：這個值會被推遲執行

通過匯編進行底層分析

1.分析下面這個函式的記憶體布局

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

var fn = sum
print(MemoryLayout.stride(ofValue: fn)) // 16

反匯編之后

可以看到底層會先計算sum的值，然后移動到fn的前8個位元組，再將0移動到fn的后8個位元組，總共占用16個位元組

兩個地址相差8個位元組，所以是連續的，都表示fn的前后8個位元組的地址值

2.分析下面這個函式的記憶體布局

typealias Fn = (Int) -> Int

func getFn() -> Fn {
    var num = 0
    
    func plus(_ i: Int) -> Int {
        return i
    }
    return plus
}

var fn = getFn()

print(Mems.size(ofVal: &fn)) // 16

反匯編之后

我們先能看到呼叫getFn之后rax和rdx會給fn分配16個位元組

然后我們進入getFn看看rax和rdx存盤的值分別是什么

可以看到會將plus的回傳值放到rax中

可以看到ecx和自己進行異或運算，并把結果0存盤到rdx中

所以回過頭看第一張圖就知道了，fn的16個位元組中，前8個位元組存盤的是plus的回傳值，后8個位元組存盤的是0

等同于將plus函式賦值給fn

var fn = plus()

3.分析下面這個函式的記憶體布局

我們將上面示例里的plus函式內部對num進行捕獲，看看其記憶體布局有什么變化

typealias Fn = (Int) -> Int

func getFn() -> Fn {
    var num = 0
    
    func plus(_ i: Int) -> Int {
        num += i
        return num
    }
    return plus
}

var fn = getFn()

fn(1)
fn(2)
fn(3)

print(Mems.size(ofVal: &fn)) // 16

反匯編之后

我們可以看到，呼叫完getFn之后，會分別將rax和rdx的值移動到rip+記憶體地址，也就是給全域變數fn進行賦值操作

我們通過列印獲取fn的記憶體占用知道是16個位元組，fn的前8個位元組就是rax里存盤的值，而后8個位元組存盤的是rdx里的值

我們只需要找到rax和rdx里分別存盤的是什么就可以了

可以看到在堆空間分配完記憶體之后的rax給上面幾個都進行了賦值，最后的rdx里存盤的就是堆空間的地址值

從這句看rax里存盤的應該是和plus函式相關，下面我們就要找到rax里存盤的是什么

而且我們呼叫fn(1)時也可以推匯出是呼叫的全域變數fn的前八個位元組

引數1會存盤到edi中

而經過上面的推導我們知道-0xf8(%rbp)中存盤的是fn的前8個位元組，那么往后8位就是-0x100(%rbp)，里面放的肯定就是堆空間的地址值了，存盤到了r13中

我們在這里打斷點，來觀察rax里到底存盤的是什么

經過一系列的跳轉，重要來到了plus真正的函式地址

而且r13最后給了rsi，rdi中存盤的還是引數1

進到plus函式中，然后找到進行相加計算的地方，因為傳進來的引數是變化的，所以不可能是和固定地址值進行相加

通過推導得知rcx里存盤的值就是rdi中的引數1

通過推導得知rdx里存盤的值就是rsi中的堆記憶體的num地址

所以可以得知0x10(%rdx)也就是rdx跳過16個位元組的值就是num的值

通過列印也可以證明我們的分析是正確的

通過推導可以發現rax中存盤的是rsi的num的地址值

然后將rcx中的值覆寫掉rax中的num地址值

而且真正進行捕獲變數的時機是在getFn即將return之前做的事

4.分析下面這個函式的記憶體布局

我們來看下面這個閉包里的變數會被捕獲幾次

typealias Fn = (Int) -> (Int, Int)

func getFns() -> (Fn, Fn) {
    var num1 = 0
    var num2 = 0

    func plus(_ i: Int) -> (Int, Int) {
        num1 += i // 6 + 0 = 6, 1 + 4 = 5,
        num2 += i << 1 // 1100 = 12 + 0 = 12, 1000 = 8 + 2 = 10
        return (num1, num2)
    }

    func minus(_ i: Int) -> (Int, Int) {
        num1 -= i // 6 - 5 = 1, 5 - 3 = 2
        num2 -= i << 1 // 1010 = 12 - 10 = 2, 0110 = 10 - 6 = 4
        return (num1, num2)
    }

    return (plus, minus)
}

let (p, m) = getFns()
print(p(6)) // 6, 12
print(m(5)) // 1, 2
print(p(4)) // 5, 10
print(m(3)) // 2, 4

反匯編之后

發現其底層分別會分配兩個堆空間，但是num1、num2也只是分別捕獲一次，然后兩個函式plus、minus共有

標籤：iOS

上一篇：Swift 進階（四）結構體和類

下一篇：iPhone及Android主要手機型號的螢屏邏輯解析度