Golang中的Defer必掌握的7知識點

在用Golang開發的時候，defer這個語法也是必備的知識，但是我們除了知道他是在一個函數退出之前執行，對於defer是否還有其他地方需要注意的呢。本文整理的defer的全場景使用情況，部分場景源自網絡，加上自己的額外觀點和分析，完成了這份defer的7個隱性必備知識點。

知識點1：defer的執行順序

知識點2:  defer與return誰先誰後

知識點3：函數的返回值初始化與defer間接影響

知識點4：有名函數返回值遇見defer情況

知識點5：defer遇見panic

知識點6：defer中包含panic

知識點7：defer下的函數參數包含子函數

多個defer出現的時候，它是一個「棧」的關係，也就是先進後出。一個函數中，寫在前面的defer會比寫在後面的defer調用的晚。

示例代碼

package main

import "fmt"

func main() {
defer func1()
defer func2()
defer func3()
}

func func1() {
fmt.Println("A")
}

func func2() {
fmt.Println("B")
}

func func3() {
fmt.Println("C")
}

輸出結果：

C
B
A

示例代碼

package main

import "fmt"

func deferFunc() int {
fmt.Println("defer func called")
return 0
}

func returnFunc() int {
fmt.Println("return func called")
return 0
}

func returnAndDefer() int {

defer deferFunc()

return returnFunc()
}

func main() {
returnAndDefer()
}

執行結果為：

return func called
defer func called

結論為：return之後的語句先執行，defer後的語句後執行

該知識點不屬於defer本身，但是調用的場景卻與defer有聯繫，所以也算是defer必備了解的知識點之一。

如 ： func DeferFunc1(i int) (t int) {}
其中返回值t int，這個t會在函數起始處被初始化為對應類型的零值並且作用域為整個函數。

示例代碼

package main

import "fmt"

func DeferFunc(i int) (t int) {

fmt.Println("t = ", t)

return 2
}

func main() {
DeferFunc(10)
}

結果

t = 0

證明，只要聲明函數的返回值變量名稱，就會在函數初始化時候為之賦值為0，而且在函數體作用域可見。

在沒有defer的情況下，其實函數的返回就是與return一致的，但是有了defer就不一樣了。

我們通過知識點2得知，先return，再defer，所以在執行完return之後，還要再執行defer裡的語句，依然可以修改本應該返回的結果。

package main

import "fmt"

func returnButDefer() (t int) { //t初始化0， 並且作用域為該函數全域

defer func() {
t = t * 10
}()

return 1
}

func main() {
fmt.Println(returnButDefer())
}

該returnButDefer()本應的返回值是1，但是在return之後，又被defer的匿名func函數執行，所以t=t*10被執行，最後returnButDefer()返回給上層main()的結果為10

$ go run test.go
10

我們知道，能夠觸發defer的是遇見return(或函數體到末尾)和遇見panic。

根據知識點2，defer遇見return情況如下：

那麼，遇到panic時，遍曆本協程的defer鍊表，並執行defer。在執行defer過程中:遇到recover則停止panic，返回recover處繼續往下執行。如果沒有遇到recover，遍歷完本協程的defer鍊表後，向stderr拋出panic信息。

A. defer遇見panic，但是並不捕獲異常的情況

package main

import (
"fmt"
)

func main() {
defer_call()

fmt.Println("main 正常結束")
}

func defer_call() {
defer func() { fmt.Println("defer: panic 之前1") }()
defer func() { fmt.Println("defer: panic 之前2") }()

panic("異常內容") //觸發defer出棧

defer func() { fmt.Println("defer: panic 之後，永遠執行不到") }()
}

結果

defer: panic 之前2
defer: panic 之前1
panic: 異常內容
//... 異常堆棧信息

B. defer遇見panic，並捕獲異常

package main

import (
"fmt"
)

func main() {
defer_call()

fmt.Println("main 正常結束")
}

func defer_call() {

defer func() {
fmt.Println("defer: panic 之前1, 捕獲異常")
if err := recover(); err != nil {
fmt.Println(err)
}
}()

defer func() { fmt.Println("defer: panic 之前2, 不捕獲") }()

panic("異常內容") //觸發defer出棧

defer func() { fmt.Println("defer: panic 之後, 永遠執行不到") }()
}

結果

defer: panic 之前2, 不捕獲
defer: panic 之前1, 捕獲異常
異常內容
main 正常結束

defer 最大的功能是 panic 後依然有效
所以defer可以保證你的一些資源一定會被關閉，從而避免一些異常出現的問題。

編譯執行下面代碼會出現什麼?

package main

import (
"fmt"
)

func main() {

defer func() {
if err := recover(); err != nil{
fmt.Println(err)
}else {
fmt.Println("fatal")
}
}()

defer func() {
panic("defer panic")
}()

panic("panic")
}

結果

defer panic

分析

panic僅有最後一個可以被revover捕獲。

觸發panic("panic")後defer順序出棧執行，第一個被執行的defer中 會有panic("defer panic")異常語句，這個異常將會覆蓋掉main中的異常panic("panic")，最後這個異常被第二個執行的defer捕獲到。

package main

import "fmt"

func function(index int, value int) int {

fmt.Println(index)

return index
}

func main() {
defer function(1, function(3, 0))
defer function(2, function(4, 0))
}

這裡，有4個函數，他們的index序號分別為1，2，3，4。

那麼這4個函數的先後執行順序是什麼呢？這裡面有兩個defer， 所以defer一共會壓棧兩次，先進棧1，後進棧2。那麼在壓棧function1的時候，需要連同函數地址、函數形參一同進棧，那麼為了得到function1的第二個參數的結果，所以就需要先執行function3將第二個參數算出，那麼function3就被第一個執行。同理壓棧function2，就需要執行function4算出function2第二個參數的值。然後函數結束，先出棧fuction2、再出棧function1.

所以順序如下：

defer出棧function2

調用function2 --> 列印2

defer出棧function1

調用function1--> 列印1

3
4
2
1

了解以上7個defer的知識點，我們來驗證一下網上的真題吧。

下面代碼輸出什麼？

package main

import "fmt"

func DeferFunc1(i int) (t int) {
t = i
defer func() {
t += 3
}()
return t
}

func DeferFunc2(i int) int {
t := i
defer func() {
t += 3
}()
return t
}

func DeferFunc3(i int) (t int) {
defer func() {
t += i
}()
return 2
}

func DeferFunc4() (t int) {
defer func(i int) {
fmt.Println(i)
fmt.Println(t)
}(t)
t = 1
return 2
}

func main() {
fmt.Println(DeferFunc1(1))
fmt.Println(DeferFunc2(1))
fmt.Println(DeferFunc3(1))
DeferFunc4()
}

練習題分析DeferFunc1

func DeferFunc1(i int) (t int) {
t = i
defer func() {
t += 3
}()
return t
}

將返回值t賦值為傳入的i，此時t為1

執行return語句將t賦值給t（等於啥也沒做）

執行defer方法，將t + 3 = 4

函數返回 4
因為t的作用域為整個函數所以修改有效。

DeferFunc2

func DeferFunc2(i int) int {
t := i
defer func() {
t += 3
}()
return t
}

創建變量t並賦值為1

執行return語句，注意這裡是將t賦值給返回值，此時返回值為1（這個返回值並不是t）

執行defer方法，將t + 3 = 4

函數返回返回值1

也可以按照如下代碼理解

func DeferFunc2(i int) (result int) {
t := i
defer func() {
t += 3
}()
return t
}

上面的代碼return的時候相當於將t賦值給了result，當defer修改了t的值之後，對result是不會造成影響的。

DeferFunc3

func DeferFunc3(i int) (t int) {
defer func() {
t += i
}()
return 2
}

首先執行return將返回值t賦值為2

執行defer方法將t + 1

最後返回 3

DeferFunc4

func DeferFunc4() (t int) {
defer func(i int) {
fmt.Println(i)
fmt.Println(t)
}(t)
t = 1
return 2
}

初始化返回值t為零值 0

首先執行defer的第一步，賦值defer中的func入參t為0

執行defer的第二步，將defer壓棧

將t賦值為1

執行return語句，將返回值t賦值為2

執行defer的第三步，出棧並執行
因為在入棧時defer執行的func的入參已經賦值了，此時它作為的是一個形式參數，所以列印為0；相對應的因為最後已經將t的值修改為2，所以再列印一個2

結果

4
1
3
0
2

推薦閱讀

喜歡本文的朋友，歡迎關注「Go語言中文網」：

Go語言中文網啟用微信學習交流群，歡迎加微信：274768166，投稿亦歡迎