defer介紹
defer是golang的一個特色功能，被稱為“延遲調用函數”。當外部函數返回后執行defer。類似于其他語言的 try… catch … finally… 中的finally，當然差別還是明顯的。
在使用defer之前我們應該多了解defer的特性，這樣才能避免使用上的誤區。
1. 最簡單的defer
func test(){
defer func(){ fmt.Println("defer") }()
//todo
//...
return
//defer執行時機
}
我們可以稍微改動一下上述代碼再次確認defer的執行時機。
func main() {
fmt.Println(test())
}
func test() (i int) {
defer func() { i++ }()
defer func() { fmt.Println(i) }()
//todo
//...
fmt.Println(0)
return 1
//defer執行時機
}
output:
0
1
2
從上面示例可以發現defer執行是在return之后，且按照defer聲明的先進后出順序執行。以下是真實場景中比較常見的用法。
釋放占用的資源
func test() error {
file, err := os.Open("path")
if err != nil {
return err
}
//放在判斷err狀態之后
defer file.Close()
//todo
//...
return nil
//defer執行時機
}
捕捉處理異常
func test2() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
}()
file, err := os.Open("path")
if err != nil {
panic(err)
}
defer file.Close()
//todo
//...
return
//defer執行時機
}
輸出日志 等收尾工作
func test3() {
t1 := time.Now()
defer func() {
fmt.Printf("耗時: %f s", time.Now().Sub(t1).Seconds())
}()
//todo
//...
return
//defer執行時機
}
2. 復雜的defer
當我們已經深深記住defer的執行時機并打算翻過這一頁時，事情的發展又開始偏離初始。請看如下代碼
func test() {
i := 0
defer fmt.Println(i) //輸出 0
defer func(x int) { fmt.Println(x) }(i) //輸出 0
defer func(x *int) { fmt.Println(*x) }(i) //輸出 1
defer func() { fmt.Println(i) }() //輸出 1
i++
//todo
//...
fmt.Println(i) //輸出 1
return
}
output:
1
1
1
0 // 值未修改
0 // 值未修改
通常認為defer就像真的被挪到了return之后。
但defer的本質依然是函數調用。當執行到defer定義時，首先會對參數進行求值，然后參數被壓入函數調用棧，此時不會進入defer函數體，而是直到函數返回時才調用defer函數體。
參數被壓入函數調用棧時，如果參數是值類型，那么將復制值，如果參數是指針，那么將復制指針而不是復制指針指向的值。
defer函數體內的變量是在return后執行因此不受影響。
因此我們在使用defer時一定要明確函數的參數類型（如果有的話），其次要明確defer函數體內的變量引用是否正確。
以下是常見錯誤
func test4() error {
f, err := os.Open("A.txt")
if err != nil {
return err
}
defer func() { f.Close() }()//錯誤: 關閉是B文件,f引用被重新賦值
f, err = os.Open("B.txt")
if err != nil {
return err
}
defer func() { f.Close() }() //關閉是B文件
list := []int{1, 2}
for _, i := range list {
defer fmt.Println(i) //輸出 2 1 //i為值類型參數被復制
defer func() { fmt.Println(i) }() //錯誤: 輸出 2 2 //函數體內對i引用,留最終值
}
return nil
}
3. 更復雜點的defer
且看如下代碼
type Test struct {
name string
}
func (this *Test) Point() { // this 為指針
fmt.Println(this.name)
}
func (this Test) Value() { //this 為值類型
fmt.Println(this.name)
}
func test5() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
defer t.Point() //輸出 c c c
defer t.Value() //輸出 c b a
}
}
看似相同的代碼卻輸出了完全不同的結果。要理解這種差別還是得從調用函數的本質來說。golang對struct 的方法調用是這樣的
defer func (this Type, para) result
struct 的方法在定義時this 采用的值類型還是指針決定defer在調用時首個參數(隱藏)的復制的不同。
上述代碼中Point方法定義時使用了指針作為this，因此輸出是for循環最終賦值的t引用。
Value方法定義時使用值類型作為this，因此輸出是for循環執行的每步復制后的t。
最終只有理解了以上出現的問題，到此defer所帶來困擾才能遠離我們。
補充：Golang中defer的三個實戰要點
Golang中的defer是使用頻次比較高的，能創造出延遲生效特效的一種方式。
defer也有自己的矯情，需要注意的。
本文將從通過代碼的方式來說明defer的三點矯情。
1.defer的生效順序
先說結論：defer的執行順序是倒序執行（同入棧先進后出）
func main() {
defer func() {
fmt.Println("我后出來")
}()
defer func() {
fmt.Println("我先出來")
}()
}
執行后打印出：
我先出來
我后出來
2.defer與return,函數返回值之間的順序
先說結論：return最先執行->return負責將結果寫入返回值中->接著defer開始執行一些收尾工作->最后函數攜帶當前返回值退出
返回值的表達方式，我們知道根據是否提前聲明有兩種方式：一種是func test() int 另一種是 func test() (i int)，所以兩種情況都來說說
func test() int
func main() {
fmt.Println("main:", test())
}
func test() int {
var i int
defer func() {
i++
fmt.Println("defer2的值:", i)
}()
defer func() {
i++
fmt.Println("defer1的值:", i)
}()
return i
}
輸出：
defer1的值: 1
defer2的值: 2
main: 0
詳解：return的時候已經先將返回值給定義下來了，就是0，由于i是在函數內部聲明所以即使在defer中進行了++操作，也不會影響return的時候做的決定。
func test() (i int)
func main() {
fmt.Println("main:", test())
}
func test() (i int) {
defer func() {
i++
fmt.Println("defer2的值:", i)
}()
defer func() {
i++
fmt.Println("defer1的值:", i)
}()
return i
}
輸出：
defer1的值: 1
defer2的值: 2
main: 2
詳解：由于返回值提前聲明了，所以在return的時候決定的返回值還是0，但是后面兩個defer執行后進行了兩次++，將i的值變為2，待defer執行完后，函數將i值進行了返回。
3.defer定義和執行兩個步驟，做的事情
先說結論：會先將defer后函數的參數部分的值(或者地址)給先下來【你可以理解為()里頭的會先確定】，后面函數執行完，才會執行defer后函數的{}中的邏輯
func test(i *int) int {
return *i
}
func main(){
var i = 1
// defer定義的時候test(i)的值就已經定了，是1，后面就不會變了
defer fmt.Println("i1 =" , test(i))
i++
// defer定義的時候test(i)的值就已經定了，是2，后面就不會變了
defer fmt.Println("i2 =" , test(i))
// defer定義的時候，i就已經確定了是一個指針類型，地址上的值變了，這里跟著變
defer func(i *int) {
fmt.Println("i3 =" , *i)
}(i)
// defer定義的時候i的值就已經定了，是2，后面就不會變了
defer func(i int) {
//defer 在定義的時候就定了
fmt.Println("i4 =" , i)
}(i)
defer func() {
// 地址，所以后續跟著變
var c = i
fmt.Println("i5 =" , *c)
}()
// 執行了 i=11 后才調用，此時i值已是11
defer func() {
fmt.Println("i6 =" , i)
}()
i = 11
}
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- Golang之defer 延遲調用操作
- 聊聊golang的defer的使用
- Golang學習筆記之延遲函數(defer)的使用小結
- golang中defer的關鍵特性示例詳解
- golang中defer的使用規則詳解
- Golang巧用defer進行錯誤處理的方法
