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í)行失敗的時候程序返回但沒有關(guān)閉前面成功打開的src，資源沒有正確關(guān)閉，正確代碼如下：

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

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

運行結(jié)果：

runtime error: integer divide by zero

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

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

函數(shù)return的時候
當前協(xié)程發(fā)生panic的時候

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

這兩點很重要：

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

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

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

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完之后結(jié)果會是1,1

對于第二個defer, 沒有傳入?yún)?shù)，結(jié)果會和最后的num和numptr地址對應(yīng)的內(nèi)容相同

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

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

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

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

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

設(shè)置返回值
執(zhí)行defer
將結(jié)果返回

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

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

情況一：延遲函數(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])
   }
}

運行結(jié)果為 num is 1 以及 100,2,3,4

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

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

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. 結(jié)果返回2
}
// return 1
func deferRun2() int {   // 注意這里返回值是匿名的，我們可以在心里為這個匿名的返回值取名為res
   var num int
   defer func() {
      num++
   }()
   return 1  //1.匿名返回值參數(shù)(res)賦值為1  //2.執(zhí)行defer語句，num++,加了個寂寞 //3.結(jié)果返回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.結(jié)果返回1
}
//return 2
func deferRun4() (res int) {
   num := 1
   defer func() {
      res++
   }()
   return num //1.返回值參數(shù)res賦值為1  //2.執(zhí)行defer語句，res++ //3.結(jié)果返回2
}