[TOC] ## 7、Golang中的Defer必掌握的7知識點 ### 知識點1：defer的執行順序 多個defer出現的時候，**它是一個“棧”的關系，也就是先進后出**。一個函數中，寫在前面的defer會比寫在后面的defer調用的晚。 > 示例代碼 ```go 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") } ```  輸出結果： ```bash C B A ``` --- ### 知識點2: defer與return誰先誰后 > 示例代碼 ```go 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() } ``` 執行結果為： ```bash return func called defer func called ``` 結論為：**return之后的語句先執行，defer后的語句后執行** --- ### 知識點3：函數的返回值初始化 該知識點不屬于defer本身，但是調用的場景卻與defer有聯系，所以也算是defer必備了解的知識點之一。 如 ： `func DeferFunc1(i int) (t int) {}` 其中返回值`t int`，這個`t`會在函數起始處被初始化為對應類型的零值并且作用域為整個函數。  > 示例代碼 ```go package main import "fmt" func DeferFunc1(i int) (t int) { fmt.Println("t = ", t) return 2 } func main() { DeferFunc11(10) } ``` 結果 ```bash t = 0 ``` 證明，**只要聲明函數的返回值變量名稱，就會在函數初始化時候為之賦值為0，而且在函數體作用域可見**。 --- ### 知識點4: 有名函數返回值遇見defer情況 ? 在沒有defer的情況下，其實函數的返回就是與return一致的，但是有了defer就不一樣了。 ? 我們通過**知識點2**得知，先return，再defer，所以在執行完return之后，還要再執行defer里的語句，依然可以修改本應該返回的結果。 ```go 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` ```bash $ go run test.go 10 ``` --- ### 知識點5: defer遇見panic ? 我們知道，能夠觸發defer的是遇見return(或函數體到末尾)和遇見panic。 ? 根據**知識點2**，我們知道，defer遇見return情況如下：  ? 那么，遇到panic時，遍歷本協程的defer鏈表，并執行defer。在執行defer過程中:遇到recover則停止panic，返回recover處繼續往下執行。如果沒有遇到recover，遍歷完本協程的defer鏈表后，向stderr拋出panic信息。  #### A. defer遇見panic，但是并不捕獲異常的情況 > test10.go ```go 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 之后，永遠執行不到") }() } ``` **結果** ```bash defer: panic 之前2 defer: panic 之前1 panic: 異常內容 //... 異常堆棧信息 ``` #### B. defer遇見panic，并捕獲異常 ```go 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 之后, 永遠執行不到") }() } ``` **結果** ```go defer: panic 之前2, 不捕獲 defer: panic 之前1, 捕獲異常 異常內容 main 正常結束 ``` **defer 最大的功能是 panic 后依然有效** 所以defer可以保證你的一些資源一定會被關閉，從而避免一些異常出現的問題。 --- ### 知識點6: defer中包含panic > 編譯執行下面代碼會出現什么? > test16.go ```go 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") } ``` **結果** ```bash defer panic ``` **分析** **panic僅有最后一個可以被revover捕獲**。 觸發`panic("panic")`后defer順序出棧執行，第一個被執行的defer中 會有`panic("defer panic")`異常語句，這個異常將會覆蓋掉main中的異常`panic("panic")`，最后這個異常被第二個執行的defer捕獲到。 --- ### 知識點7: defer下的函數參數包含子函數 ```go 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壓棧function1，壓棧函數地址、形參1、形參2(調用function3) --> 打印3 * defer壓棧function2，壓棧函數地址、形參1、形參2(調用function4) --> 打印4 * defer出棧function2, 調用function2 --> 打印2 * defer出棧function1, 調用function1--> 打印1 ```bash 3 4 2 1 ``` --- ### 練習：defer面試真題 了解以上6個defer的知識點，我們來驗證一下網上的真題吧。 下面代碼輸出什么？ > test11.go ```go 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 ```go func DeferFunc1(i int) (t int) { t = i defer func() { t += 3 }() return t } ``` 1. 將返回值t賦值為傳入的i，此時t為1 2. 執行return語句將t賦值給t（等于啥也沒做） 3. 執行defer方法，將t + 3 = 4 4. 函數返回 4 因為t的作用域為整個函數所以修改有效。 #### DeferFunc2 ```go func DeferFunc2(i int) int { t := i defer func() { t += 3 }() return t } ``` 1. 創建變量t并賦值為1 2. 執行return語句，注意這里是將t賦值給返回值，此時返回值為1（這個返回值并不是t） 3. 執行defer方法，將t + 3 = 4 4. 函數返回返回值1 也可以按照如下代碼理解 ```go func DeferFunc2(i int) (result int) { t := i defer func() { t += 3 }() return t } ``` 上面的代碼return的時候相當于將t賦值給了result，當defer修改了t的值之后，對result是不會造成影響的。 #### DeferFunc3 ```go func DeferFunc3(i int) (t int) { defer func() { t += i }() return 2 } ``` 1. 首先執行return將返回值t賦值為2 2. 執行defer方法將t + 1 3. 最后返回 3 #### DeferFunc4 ```go func DeferFunc4() (t int) { defer func(i int) { fmt.Println(i) fmt.Println(t) }(t) t = 1 return 2 } ``` 1. 初始化返回值t為零值 0 2. 首先執行defer的第一步，賦值defer中的func入參t為0 3. 執行defer的第二步，將defer壓棧 4. 將t賦值為1 5. 執行return語句，將返回值t賦值為2 6. 執行defer的第三步，出棧并執行 因為在入棧時defer執行的func的入參已經賦值了，此時它作為的是一個形式參數，所以打印為0；相對應的因為最后已經將t的值修改為2，所以再打印一個2 #### **結果** ```bash 4 1 3 0 2 ```