Go基礎系列：defer、panic和recover

defer關鍵字

defer關鍵字可讓函數或語句延遲到函數語句塊的最結尾時，即即將退出函數時執行，即使函數中途報錯結束、即使已經panic()、即使函數已經return了，也都會執行defer所推遲的對象。

其實defer的本質是，當在某個函數中使用了defer關鍵字，則建立一個獨立的defer棧幀，並將該defer語句壓入棧中，同時將其使用的相關變量也拷貝到該棧幀中（顯然是按值拷貝的）。由於棧是LIFO方式，因此先壓棧的後執行。由於是獨立的棧幀，因此即便調用者函數已經返回或報錯，也同樣能在它們以後進入defer棧幀去執行。

例如：

func main() {
    a()
}

func a() {
    println("in a")
    defer b()              // 將b()壓入defer棧中
    println("leaving a")
    //到了這裏纔會執行b()
}

func b() {
    println("in b")
    println("leaving b")
}

上面將輸出：

in a
leaving a
in b
leaving b

即使是函數已經報錯，或函數已經return返回，defer的對象也會在函數退出前的最後一刻執行。

func a() TYPE{
    ...CODE...
    
    defer b()
    
    ...CODE...
    
    // 函數執行出了錯誤
    
    return args
    // 函數b()都會在這裏執行
}

但注意，因爲Go的做用域採用的是詞法做用域，defer的定義位置決定了它推遲對象能看見的變量值，而不是推遲對象被調用時所能看見的值。

例如：

package main

var x = 10
func main() {
    a()
}

func a() {
    println("start a:",x)   // 輸出10
    x = 20
    defer b(x)       // 壓棧，並按值拷貝20到棧中
    x = 30
    println("leaving a:",x)  // 輸出30
    // 調用defer延遲的對象b()，輸出20
}

func b(x int) {
    println("start b:",x)
}

比較下面的defer：

package main

var x = 10

func main() {
    a()
}

func a() int {
    println("start a:", x) // 輸出10
    x = 20
    defer func() {      // 壓棧，但並未傳值，因此內部引用x
        println("in defer:", x)  // 輸出30
    }()
    x = 30
    println("leaving a:", x) // 輸出30
    return x
}

上面defer推遲的匿名函數輸出的值是30，它看見的不該該是20嗎？先再改爲下面的：

package main

var x = 10

func main() {
    a()
}

func a() int {
    println("start a:", x) // 輸出10
    x = 20
    defer func(x int) {
        println("in defer:", x)  // 輸出20
    }(x)
    x = 30
    println("leaving a:", x) // 輸出30
    return x
}

這個defer推遲的對象中看見的倒是20，這和第一種defer b(x)是相同的。

緣由在於defer推遲的若是是函數，它直接就在它的定義位置處評估好參數、變量。該拷貝傳值的拷貝傳值，該指針相見的指針相見。因此，對於第(1)和第(3)種狀況，在defer的定義位置處，就將x=20拷貝給了推遲的函數參數，因此函數內部操做的一直是x的副本。而第二種狀況則是直接指向它所看見的x=20那個變量，則個變量是全局變量，當執行x=30的時候會將其值修改，到執行defer推遲的對象時，它指向的x的值已是修改過的。

再看下面這個例子，將defer放進一個語句塊中，並在這個語句塊中新聲明一個同名變量x：

func a() int {
    println("start a:", x) // 輸出10
    x = 20
    {
        x := 40
        defer func() {
            println("in defer:", x)  // 輸出40
        }()
    }
    x = 30
    println("leaving a:", x) // 輸出30
    return x
}

上面的defer定義在語句塊中，它能看見的x是語句塊中x=40，它的x指向的是語句塊中的x。另外一方面，當語句塊結束時，x=40的x會消失，但因爲defer的函數中仍有x指向40這個值，因此40這個值仍被defer的函數引用着，它直到defer執行完以後纔會被GC回收。因此defer的函數在執行的時候，仍然會輸出40。

若是語句塊內有多個defer，則defer的對象以LIFO(last in first out)的方式執行，也就是說，先定義的defer後執行。

func main() {
    println("start...")
    defer println("1")
    defer println("2")
    defer println("3")
    defer println("4")
    println("end...")
}

將輸出：

start...
end...
4
3
2
1

defer有什麼用呢？通常用來作善後操做，例如清理垃圾、釋放資源，不管是否報錯都執行defer對象。另外一方面，defer可讓這些善後操做的語句和開始語句放在一塊兒，不管在可讀性上仍是安全性上都頗有改善，畢竟寫完開始語句就能夠直接寫defer語句，永遠也不會忘記關閉、善後等操做。

例如，打開文件，關閉文件的操做寫在一塊兒：

open()
defer file.Close()
... 操做文件 ...

如下是defer的一些經常使用場景：

• 打開關閉文件
  
• 鎖定、釋放鎖
  
• 創建鏈接、釋放鏈接
  
• 做爲結尾輸出結尾信息
  
• 清理垃圾(如臨時文件)

panic()和recover()

panic()用於產生錯誤信息並終止當前的goroutine，通常將其看做是退出panic()所在函數以及退出調用panic()所在函數的函數。例如，G()中調用F()，F()中調用panic()，則F()退出，G()也退出。

注意，defer關鍵字推遲的對象是函數最後調用的，即便出現了panic也會調用defer推遲的對象。

例如，下面的代碼中，main()中輸出一個start main以後調用a()，它會輸出start a，而後就panic了，panic()會輸出panic: panic in a，而後報錯，終止程序。

func main() {
    println("start main")
    a()
    println("end main")
}

func a() {
    println("start a")
    panic("panic in a")
    println("end a")
}

執行結果以下：

start main
start a
panic: panic in a

goroutine 1 [running]:
main.a()
        E:/learning/err.go:14 +0x63
main.main()
        E:/learning/err.go:8 +0x4c
exit status 2

注意上面的end a和end main都沒有被輸出。

可使用recover()去捕獲panic()並恢復執行。recover()用於捕捉panic()錯誤，並返回這個錯誤信息。但注意，即便recover()捕獲到了panic()，但調用含有panic()函數的函數(即上面的G()函數)也會退出，因此若是recover()定義在G()中，則G()中調用F()函數以後的代碼都不會執行(見下面的通用格式)。

如下是比較通用的panic()和recover()的格式：

func main() {
    G()
    // 下面的代碼會執行
    ...CODE IN MAIN...
}
func G(){
    defer func (){
        if str := recover(); str != nil {
            fmt.Println(str)
        }
    }()
    ...CODE IN G()...
    
    // F()的調用必須在defer關鍵字以後
    F()
    // 該函數內下面的代碼不會執行
    ...CODE IN G()...
}
func F() {
    ...CODE1...
    panic("error found")
    // 下面的代碼不會執行
    ...CODE IN F()...
}

可使用recover()去捕獲panic()並恢復執行。但如下代碼是錯誤的：

func main() {
    println("start main")
    a()
    println("end main")
}

func a() {
    println("start a")
    panic("panic in a")

    // 直接放在panic後是錯誤的
    panic_str := recover()
    println(panic_str)

    println("end a")
}

之因此錯誤，是由於panic()一出現就直接退出函數a()和main()了。要想recover()真正捕獲panic()，須要將recover()放在defer的推遲對象中，且defer的定義必須在panic()發生以前。

例如，下面是通用格式的示例：

package main

import "fmt"

func main() {
    println("start main")
    b()
    println("end main")
}

func a() {
    println("start a")
    panic("panic in a")
    println("end a")
}

func b() {
    println("start b")
    defer func() {
        if str := recover(); str != nil {
            fmt.Println(str)
        }
    }()
    a()
    println("end b")
}

如下是輸出結果：

start main
start b
start a
panic in a
end main

注意上面的end b、end a都沒有被輸出，可是end main輸出了。

panic()是內置的函數(在包builtin中)，在log包中也有一個Panic()函數，它調用Print()輸出信息後，再調用panic()。go doc log Panic一看便知：

$ go doc log Panic
func Panic(v ...interface{})
    Panic is equivalent to Print() followed by a call to panic().