Go 語言中延遲函數 defer 充當着 try...catch 的重任，使用起來也非常簡便，然而在實際應用中，很多 gopher 並沒有真正搞明白 defer、return、返回值、panic 之間的執行順序，從而掉進坑中，今天我們就來揭開它的神秘面紗！
先來運行下面兩段代碼：
A. 匿名返回值的情況
package main
import (
"fmt"
)
func main() {
fmt.Println("a return:", a()) // 打印結果為 a return: 0
}
func a() int {
var i int
defer func() {
i++
fmt.Println("a defer2:", i) // 打印結果為 a defer2: 2
}()
defer func() {
i++
fmt.Println("a defer1:", i) // 打印結果為 a defer1: 1
}()
return i
}
B. 有名返回值的情況
package main
import (
"fmt"
)
func main() {
fmt.Println("b return:", b()) // 打印結果為 b return: 2
}
func b() (i int) {
defer func() {
i++
fmt.Println("b defer2:", i) // 打印結果為 b defer2: 2
}()
defer func() {
i++
fmt.Println("b defer1:", i) // 打印結果為 b defer1: 1
}()
return i // 或者直接 return 效果相同
}
先來假設出結論（這是正確結論），幫助大家理解原因：
-
多個 defer 的執行順序為“后進先出/先進后出”；
-
所有函數在執行 RET 返回指令之前，都會先檢查是否存在 defer 語句，若存在則先逆序調用 defer 語句進行收尾工作再退出返回；
-
匿名返回值是在 return 執行時被聲明，有名返回值則是在函數聲明的同時被聲明，因此在 defer 語句中只能訪問有名返回值，而不能直接訪問匿名返回值；
-
return 其實應該包含前后兩個步驟：第一步是給返回值賦值（若為有名返回值則直接賦值，若為匿名返回值則先聲明再賦值）；第二步是調用 RET 返回指令並傳入返回值，而 RET 則會檢查 defer 是否存在，若存在就先逆序插播 defer 語句，最后 RET 攜帶返回值退出函數；
因此，defer、return、返回值三者的執行順序應該是：return最先給返回值賦值；接着 defer 開始執行一些收尾工作；最后 RET 指令攜帶返回值退出函數。
如何解釋兩種結果的不同：
上面兩段代碼的返回結果之所以不同，其實從上面的結論中已經很好理解了。
-
a()int 函數的返回值沒有被提前聲名，其值來自於其他變量的賦值，而 defer 中修改的也是其他變量（其實該 defer 根本無法直接訪問到返回值），因此函數退出時返回值並沒有被修改。
-
b()(i int) 函數的返回值被提前聲名，這使得 defer 可以訪問該返回值，因此在 return 賦值返回值 i 之后，defer 調用返回值 i 並進行了修改，最后致使 return 調用 RET 退出函數后的返回值才會是 defer 修改過的值。
C. 下面我們再來看第三個例子，驗證上面的結論：
package main
import (
"fmt"
)
func main() {
c:=c()
fmt.Println("c return:", *c, c) // 打印結果為 c return: 2 0xc082008340
}
func c() *int {
var i int
defer func() {
i++
fmt.Println("c defer2:", i, &i) // 打印結果為 c defer2: 2 0xc082008340
}()
defer func() {
i++
fmt.Println("c defer1:", i, &i) // 打印結果為 c defer1: 1 0xc082008340
}()
return &i
}
雖然 c()int 的返回值沒有被提前聲明，但是由於 c()int 的返回值是指針變量，那么在 return 將變量 i 的地址賦給返回值后，defer 再次修改了 i 在內存中的實際值，因此 return 調用 RET 退出函數時返回值雖然依舊是原來的指針地址，但是其指向的內存實際值已經被成功修改了。
即，我們假設的結論是正確的！
D. 補充一條，defer聲明時會先計算確定參數的值，defer推遲執行的僅是其函數體。
package main
import (
"fmt"
"time"
)
func main() {
defer P(time.Now())
time.Sleep(5e9)
fmt.Println("main ", time.Now())
}
func P(t time.Time) {
fmt.Println("defer", t)
fmt.Println("P ", time.Now())
}
// 輸出結果：
// main 2017-08-01 14:59:47.547597041 +0800 CST
// defer 2017-08-01 14:59:42.545136374 +0800 CST
// P 2017-08-01 14:59:47.548833586 +0800 CST
E. defer 的作用域
-
defer 只對當前協程有效（main 可以看作是主協程）；
-
當任意一條（主）協程發生 panic 時，會執行當前協程中 panic 之前已聲明的 defer；
-
在發生 panic 的（主）協程中，如果沒有一個 defer 調用 recover()進行恢復，則會在執行完最后一個已聲明的 defer 后，引發整個進程崩潰；
-
主動調用 os.Exit(int) 退出進程時，defer 將不再被執行。
package main
import (
"errors"
"fmt"
"time"
// "os"
)
func main() {
e := errors.New("error")
fmt.Println(e)
// （3）panic(e) // defer 不會執行
// （4）os.Exit(1) // defer 不會執行
defer fmt.Println("defer")
// （1）go func() { panic(e) }() // 會導致 defer 不會執行
// （2）panic(e) // defer 會執行
time.Sleep(1e9)
fmt.Println("over.")
// （5）os.Exit(1) // defer 不會執行
}
F. defer 表達式的調用順序是按照先進后出的方式執行
defer 表達式會被放入一個類似於棧( stack )的結構，所以調用的順序是先進后出/后進先出的。
下面這段代碼輸出的結果是 4321 而不是 1234 。
package main
import (
"fmt"
)
func main() {
defer fmt.Print(1)
defer fmt.Print(2)
defer fmt.Print(3)
defer fmt.Print(4)
}