腳本之家服務器常用軟件

快捷導航

Golang 的defer執(zhí)行規(guī)則說明

更新時間：2021年04月28日 10:01:23 作者：dengming0922

這篇文章主要介紹了Golang 的defer執(zhí)行規(guī)則說明，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧

defer介紹

defer是golang的一個特色功能，被稱為“延遲調(diào)用函數(shù)”。當外部函數(shù)返回后執(zhí)行defer。類似于其他語言的 try… catch … finally… 中的finally，當然差別還是明顯的。

在使用defer之前我們應該多了解defer的特性，這樣才能避免使用上的誤區(qū)。

1. 最簡單的defer

func test(){
    defer func(){ fmt.Println("defer") }()
    //todo
    //...
    return
    //defer執(zhí)行時機
}

我們可以稍微改動一下上述代碼再次確認defer的執(zhí)行時機。

func main() {
    fmt.Println(test())
}
func test() (i int) {
    defer func() { i++ }()
    defer func() { fmt.Println(i) }()
    //todo
    //...
    fmt.Println(0)
    return 1
    //defer執(zhí)行時機
}

output:

0

1

2

從上面示例可以發(fā)現(xiàn)defer執(zhí)行是在return之后，且按照defer聲明的先進后出順序執(zhí)行。以下是真實場景中比較常見的用法。

釋放占用的資源

func test() error {
    file, err := os.Open("path")
    if err != nil {
        return err
    }
    //放在判斷err狀態(tài)之后
    defer file.Close()
    //todo
    //...
    return nil
    //defer執(zhí)行時機
}

捕捉處理異常

func test2() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    file, err := os.Open("path")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    //todo
    //...
    return
    //defer執(zhí)行時機
}

輸出日志等收尾工作

func test3() {
    t1 := time.Now()
    defer func() {
        fmt.Printf("耗時: %f s", time.Now().Sub(t1).Seconds())
    }()
    //todo
    //...
    return
    //defer執(zhí)行時機
}

2. 復雜的defer

當我們已經(jīng)深深記住defer的執(zhí)行時機并打算翻過這一頁時，事情的發(fā)展又開始偏離初始。請看如下代碼

func test() {
    i := 0
    defer fmt.Println(i)                       //輸出 0
    defer func(x int) { fmt.Println(x) }(i)    //輸出 0
    defer func(x *int) { fmt.Println(*x) }(&i) //輸出 1
    defer func() { fmt.Println(i) }()          //輸出 1
    i++
    //todo
    //...
    fmt.Println(i) //輸出 1
    return   
}

output:

1

1

1

0 // 值未修改

0 // 值未修改

通常認為defer就像真的被挪到了return之后。

但defer的本質(zhì)依然是函數(shù)調(diào)用。當執(zhí)行到defer定義時，首先會對參數(shù)進行求值，然后參數(shù)被壓入函數(shù)調(diào)用棧，此時不會進入defer函數(shù)體，而是直到函數(shù)返回時才調(diào)用defer函數(shù)體。

參數(shù)被壓入函數(shù)調(diào)用棧時，如果參數(shù)是值類型，那么將復制值，如果參數(shù)是指針，那么將復制指針而不是復制指針指向的值。

defer函數(shù)體內(nèi)的變量是在return后執(zhí)行因此不受影響。

因此我們在使用defer時一定要明確函數(shù)的參數(shù)類型（如果有的話），其次要明確defer函數(shù)體內(nèi)的變量引用是否正確。

以下是常見錯誤

func test4() error {
    f, err := os.Open("A.txt")
    if err != nil {
        return err
    }
    defer func() { f.Close() }()//錯誤: 關閉是B文件,f引用被重新賦值
    f, err = os.Open("B.txt")
    if err != nil {
        return err
    }
    defer func() { f.Close() }() //關閉是B文件
    list := []int{1, 2}
    for _, i := range list {
        defer fmt.Println(i) //輸出 2 1 //i為值類型參數(shù)被復制
        defer func() { fmt.Println(i) }() //錯誤: 輸出 2 2 //函數(shù)體內(nèi)對i引用,留最終值
    }
    return nil
}

3. 更復雜點的defer

且看如下代碼

type Test struct {
    name string
}
func (this *Test) Point() { // this  為指針
    fmt.Println(this.name)
}
func (this  Test) Value() { //this  為值類型 
    fmt.Println(this.name)
}
func test5() {
    ts := []Test{{"a"}, {"b"}, {"c"}}
    for _, t := range ts {
        defer t.Point() //輸出 c c c
        defer t.Value() //輸出 c b a
    }
}

看似相同的代碼卻輸出了完全不同的結果。要理解這種差別還是得從調(diào)用函數(shù)的本質(zhì)來說。golang對struct 的方法調(diào)用是這樣的

defer func (this Type, para) result

struct 的方法在定義時this 采用的值類型還是指針決定defer在調(diào)用時首個參數(shù)(隱藏)的復制的不同。

上述代碼中Point方法定義時使用了指針作為this，因此輸出是for循環(huán)最終賦值的t引用。

Value方法定義時使用值類型作為this，因此輸出是for循環(huán)執(zhí)行的每步復制后的t。

最終只有理解了以上出現(xiàn)的問題，到此defer所帶來困擾才能遠離我們。

補充：Golang中defer的三個實戰(zhàn)要點

Golang中的defer是使用頻次比較高的，能創(chuàng)造出延遲生效特效的一種方式。

defer也有自己的矯情，需要注意的。

本文將從通過代碼的方式來說明defer的三點矯情。

1.defer的生效順序

先說結論：defer的執(zhí)行順序是倒序執(zhí)行（同入棧先進后出）

func main() {
 defer func() {
  fmt.Println("我后出來")
 }()
 defer func() {
  fmt.Println("我先出來")
 }()
}

執(zhí)行后打印出：

我先出來

我后出來

2.defer與return,函數(shù)返回值之間的順序

先說結論：return最先執(zhí)行->return負責將結果寫入返回值中->接著defer開始執(zhí)行一些收尾工作->最后函數(shù)攜帶當前返回值退出

返回值的表達方式，我們知道根據(jù)是否提前聲明有兩種方式：一種是func test() int 另一種是 func test() (i int)，所以兩種情況都來說說

func test() int
func main() {
 fmt.Println("main:", test())
}
func test() int {
 var i int
 defer func() {
  i++
  fmt.Println("defer2的值:", i)
 }()
 defer func() {
  i++
  fmt.Println("defer1的值:", i)
 }()
 return i
}

輸出：

defer1的值: 1

defer2的值: 2

main: 0

詳解：return的時候已經(jīng)先將返回值給定義下來了，就是0，由于i是在函數(shù)內(nèi)部聲明所以即使在defer中進行了++操作，也不會影響return的時候做的決定。

func test() (i int)
func main() {
 fmt.Println("main:", test())
}
func test() (i int) {
 defer func() {
  i++
  fmt.Println("defer2的值:", i)
 }()
 defer func() {
  i++
  fmt.Println("defer1的值:", i)
 }()
 return i
}

輸出：

defer1的值: 1

defer2的值: 2

main: 2

詳解：由于返回值提前聲明了，所以在return的時候決定的返回值還是0，但是后面兩個defer執(zhí)行后進行了兩次++，將i的值變?yōu)?，待defer執(zhí)行完后，函數(shù)將i值進行了返回。

3.defer定義和執(zhí)行兩個步驟，做的事情

先說結論：會先將defer后函數(shù)的參數(shù)部分的值(或者地址)給先下來【你可以理解為()里頭的會先確定】，后面函數(shù)執(zhí)行完，才會執(zhí)行defer后函數(shù)的{}中的邏輯

func test(i *int) int {
 return *i
}
func main(){
 var i = 1
 // defer定義的時候test(&i)的值就已經(jīng)定了，是1，后面就不會變了
 defer fmt.Println("i1 ="  , test(&i))
 i++
 // defer定義的時候test(&i)的值就已經(jīng)定了，是2，后面就不會變了
 defer fmt.Println("i2 ="  , test(&i))
 // defer定義的時候，i就已經(jīng)確定了是一個指針類型，地址上的值變了，這里跟著變
 defer func(i *int) {
  fmt.Println("i3 ="  , *i)
 }(&i)
 // defer定義的時候i的值就已經(jīng)定了，是2，后面就不會變了
 defer func(i int) {
  //defer 在定義的時候就定了
  fmt.Println("i4 ="  , i)
 }(i)
 defer func() {
  // 地址，所以后續(xù)跟著變
  var c = &i
  fmt.Println("i5 ="  , *c)
 }()
 
 // 執(zhí)行了 i=11 后才調(diào)用，此時i值已是11
 defer func() {
  fmt.Println("i6 ="  , i)
 }()
 i = 11
}

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。

您可能感興趣的文章: