Golang關鍵字defer怎么使用

這篇文章主要介紹了Golang關鍵字defer怎么使用的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Golang關鍵字defer怎么使用文章都會有所收獲，下面我們一起來看看吧。

1. defer的簡單介紹與使用場景

defer是Go里面的一個關鍵字，用在方法或函數(shù)前面，作為方法或函數(shù)的延遲調用。它主要用于以下兩個場景：

• 優(yōu)雅釋放資源，比如一些網絡連接、數(shù)據庫連接以及文件資源的釋放。

• 與recover配合處理panic異常

場景一：復制文件

func CopyFile(dstFile, srcFile string) (wr int64, err error) { 
    src, err := os.Open(srcFile)     
    if err != nil {         
        return     
    }      
    dst, err := os.Create(dstFile)     
    if err != nil {         
        return    
    }      
    wr, err = io.Copy(dst, src)     
    dst.Close()     
    src.Close()     
    return 
}

這樣的代碼是有問題的，當?shù)?行執(zhí)行失敗的時候程序返回但沒有關閉前面成功打開的src，資源沒有正確關閉，正確代碼如下：

（在成功打開資源，沒返回err的情況下，都可以使用defer進行優(yōu)雅的關閉資源）

func CopyFile(dstFile, srcFile string) (wr int64, err error) {
    src, err := os.Open(srcFile)
    if err != nil {
        return
    }
    defer src.Close()
    dst, err := os.Create(dstFile)
    if err != nil {
        return
    }
    defer dst.Close()
    wr, err = io.Copy(dst, src)  
    return err
}

場景二：處理異常panic

package main
import "fmt"
func main() {
   defer func() {
      if r := recover(); r != nil {
         fmt.Println(r)
      }
   }()
   a := 1
   b := 0
   fmt.Println("result:", a/b)   
}

運行結果：

runtime error: integer divide by zero

程序沒有輸出result, 會拋出panic, 因為不能對除數(shù)為0的數(shù)做除法，我們使用defer在程序發(fā)生panic的時候捕獲異常。go中是用panic拋異常，recover捕獲異常，異常會在下一篇go文章進行分析。

通過這兩個使用場景我們也可以看到defer后面跟著的函數(shù)被調用的時間：

• 函數(shù)return的時候

• 當前協(xié)程發(fā)生panic的時候

說到延遲函數(shù)被調用的時機，這時順便說一下多個延遲函數(shù)被調用時候的執(zhí)行順序問題。官方對defer的解釋中寫到每次defer語句執(zhí)行的時候，會把函數(shù)“壓棧”，同時函數(shù)參數(shù)會被拷貝下來

這兩點很重要：

一是說明當一個函數(shù)中有多個defer的時候，執(zhí)行順序是LIFO先進后出

二是說明延遲函數(shù)的參數(shù)在defer語句出現(xiàn)時就已經確定下來了

這段代碼是用來補充這二點的：看一下能否看懂執(zhí)行結果，能的話就直接跳到第二部分

func deferRun1() {
   var num = 1
   numptr := &num
   defer fmt.Println("defer run 1: \n", numptr, num, *numptr) // 0xc000022088 1 1
   defer func() {
      fmt.Println("defer run 2 : \n", numptr, num, *numptr) // 0xc000116028 2 2
   }()
   defer func(num int, numptr *int) {
      fmt.Println("defer run 3: \n", numptr, num, *numptr) //0xc000116028 1 2
   }(num, numptr)
   num = 2
   fmt.Println(numptr, num, *numptr) // 0xc000116028 2 2
   return
}

對于第一個defer，傳入的num和*numptr都是一個具體的值，所以程序return完之后結果會是1,1

對于第二個defer, 沒有傳入參數(shù)，結果會和最后的num和numptr地址對應的內容相同

對于第三個defer, 傳入的參數(shù)num是固定的值，而numptr是固定的地址，后面地址對應的內容被修改了，所以結果是1,2

同時，執(zhí)行順序會是第三個defer先執(zhí)行，然后是第二個...第一個

2. defer在return執(zhí)行的時機

第一小節(jié)上面說了有一種情況延遲函數(shù)的執(zhí)行是在return的時候，再具體一點就是在return的時候，defer操作帶來了什么結果呢？

一句話解決這個問題就是：函數(shù)return不是一個原子操作，需要經過以下三步：

• 設置返回值

• 執(zhí)行defer

• 將結果返回

一定要牢記在心中，分析的時候也要嚴格按照這三步來，否則極容易掉坑！

下面把需要注意的情況列舉出來：

情況一：延遲函數(shù)參數(shù)早已固定下來（第一小節(jié)提到的重要的一點）

func main() {
   deferRun()
   deferRun2()
}
func deferRun() {
   var num = 1
   defer fmt.Printf("num is %d\n", num)
   num = 2
   return
}
func deferRun2() {
   var arr = [4]int{1, 2, 3, 4}
   defer printArr(&arr)
   arr[0] = 100
   return
}
func printArr(arr *[4]int) {
   for i := range arr {
      fmt.Println(arr[i])
   }
}

運行結果為 num is 1 以及 100,2,3,4

道理很簡單：延遲函數(shù)的參數(shù)在defer出現(xiàn)的時候就固定了，對于deferRun，傳的參數(shù)是num的值，而對于deferRun，傳的參數(shù)是arr的地址，地址不變，但是地址對應的內容被修改，所以輸出被改變。

情況二： 嚴格把握三步走，繞開 “匿名” 小坑，分析看注釋

func main() {
   res1 := deferRun()
   fmt.Println(res1)
   res2 := deferRun2()
   fmt.Println(res2)
   res3 := deferRun3()
   fmt.Println(res3)
   res4 := deferRun4()
   fmt.Println(res4)
}
// return 2 
func deferRun() (res int) {
   num := 1
   defer func() {
      res++
   }()
   return num   //1.返回值參數(shù)res賦值為num即1  //2.執(zhí)行defer語句，res++  //3. 結果返回2
}
// return 1
func deferRun2() int {   // 注意這里返回值是匿名的，我們可以在心里為這個匿名的返回值取名為res
   var num int
   defer func() {
      num++
   }()
   return 1  //1.匿名返回值參數(shù)(res)賦值為1  //2.執(zhí)行defer語句，num++,加了個寂寞 //3.結果返回1
}
//return 1
func deferRun3() int {
   num := 1
   defer func() {
      num++
   }()
   return num  //1.匿名(res)賦值為num即1  //2.執(zhí)行defer語句，num++,加了個寂寞，num為2，res依舊為1 
              //3.結果返回1
}
//return 2
func deferRun4() (res int) {
   num := 1
   defer func() {
      res++
   }()
   return num //1.返回值參數(shù)res賦值為1  //2.執(zhí)行defer語句，res++ //3.結果返回2
}

執(zhí)行結果為 2 1 1 2

關于“Golang關鍵字defer怎么使用”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“Golang關鍵字defer怎么使用”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業(yè)資訊頻道。