go 的 defer 語句是用來延遲執行函式的，而且延遲發生在呼叫函式 return之後

defer 的作用和執行時機

go 的 defer 語句是用來延遲執行函式的，而且延遲發生在呼叫函式 return之後，比如

func a() int {
    defer b()
    return 0
}
複製程式碼

b 的執行是發生在 return 0 之後，注意 defer 的語法，關鍵字 defer 之後是函式的呼叫。

清理釋放資源

由於 defer 的延遲特性，defer 常用在函式呼叫結束之後清理相關的資源，比如

f,_ := os.Open(filename)
defer f.Close()
複製程式碼
 

檔案資源的釋放會在函式呼叫結束之後藉助 defer 自動執行，不需要時刻記住哪裡的資源需要釋放，開啟和釋放必須相對應。

用一個例子深刻詮釋一下 defer 帶來的便利和簡潔。

程式碼的主要目的是開啟一個檔案，然後複製內容到另一個新的檔案中，沒有 defer 時這樣寫：

func CopyFile(dstName,srcName string) (written int64,err error) {
    src,err := os.Open(srcName)
    if err != nil {
        return
    }
    dst,err := os.Create(dstName)
    if
 
 err != nil { //1
        return
    }
    written,err = io.Copy(dst,src)
    dst.Close()
    src.Close()
    return
}
複製程式碼

程式碼在 //1 處返回之後，src 檔案沒有執行關閉操作，可能會導致資源不能正確釋放，改用 defer 實現：

func CopyFile(dstName,err := os.Open(srcName)
    if err != nil {
        return
    }
    defer src.Close()
    dst,err := os.Create(dstName)
    if
 
 err != nil {
        return
    }
    defer dst.Close()
    return io.Copy(dst,src)
}
複製程式碼

src 和 dst 都能及時清理和釋放，無論 return 在什麼地方執行。

鑑於 defer 的這種作用，defer 常用來釋放資料庫連線，檔案開啟控制程式碼等釋放資源的操作。

執行 recover

被 defer 的函式在 return 之後執行，這個時機點正好可以捕獲函式丟擲的 panic，因而 defer 的另一個重要用途就是執行 recover。

recover 只有在 defer 中使用才更有意義，如果在其他地方使用，由於 program 已經呼叫結束而提前返回而無法有效捕捉錯誤。

package main
import (
    "fmt"
)
func main() {
    defer func() {
        if ok := recover(); ok != nil {
            fmt.Println("recover")
        }
    }()
    panic("error")
}
複製程式碼

記住 defer 要放在 panic 執行之前。

多個 defer 的執行順序

defer 的作用就是把關鍵字之後的函式執行壓入一個棧中延遲執行，多個 defer 的執行順序是後進先出 LIFO ：

defer func() { fmt.Println("1") }()
defer func() { fmt.Println("2") }()
defer func() { fmt.Println("3") }()
複製程式碼

輸出順序是 321。這個特性可以對一個 array 實現逆序操作。

被 deferred 函式的引數在 defer 時確定

這是 defer 的特點，一個函式被 defer 時，它的引數在 defer 時進行計算確定，即使 defer 之後引數發生修改，對已經 defer 的函式沒有影響，什麼意思？看例子：

func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
}
複製程式碼

a 執行輸出的是 0 而不是 1，因為 defer 時，i 的值是 0，此時被 defer 的函式引數已經進行執行計算並確定了。

再看一個例子：

func calc(index string,a,b int) int {
    ret := a + b
    fmt.Println(index,b,ret)
    return ret
}
func main() {
    a := 1
    b := 2
    defer calc("1",calc("10",b))
    a = 0
    return
}
複製程式碼

執行程式碼輸出

10 1 2 3
1 1 3 4
複製程式碼

defer 函式的引數 第三個引數在 defer 時就已經計算完成並確定，第二個引數 a 也是如此，無論之後 a 變數是否修改都不影響。

被 defer 的函式可以讀取和修改帶名稱的返回值

func c() (i int) {
    defer func() { i++ }()
    return 1
}
複製程式碼

被 defer 的函式是在 return 之後執行，可以修改帶名稱的返回值，上面的函式 c 返回的是 2。