Defer learning in golang

1：defer Execution order of

Multiple defer When it appears , It's a “ Stack ” The relationship between , That is, first in and then out . In a function , Written in the front defer It'll be better than the one written later defer Late call .

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")
}

Output results ： C B A

2: defer And return Whoever first after

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()
}

The execution result is ：

return func called
defer func called

The conclusion is ：return The following statement executes ,defer Execute after the following statement

3： The return value of the function initializes

This knowledge point does not belong to defer In itself , But the scene of the call is different from defer There's a connection , So it's sort of defer One of the necessary knowledge points .

Such as ： func DeferFunc1(i int) (t int) {}
Where the return value t int, This t It will be initialized to the zero value of the corresponding type at the beginning of the function, and the scope is the whole function

package main

import "fmt"

func DeferFunc1(i int) (t int) {

    fmt.Println("t = ", t)

    return 2
}

func main() {
    DeferFunc11(10)
}

result ：t=0

prove , Just declare the return value of the function and the variable name , When the function is initialized, it will be assigned a value of 0, And it can be seen in the scope of the function body .

4: The return value of a famous function meets defer situation

​ In the absence of defer Under the circumstances , In fact, the return of a function is the same as return coincident , But with defer Not so .

​ We go through Knowledge point 2 hear , First return, Again defer, So at the end of the execution return after , We have to do it again defer The sentence in , You can still modify the results that should have been returned .

package main

import "fmt"

func returnButDefer() (t int) {  //t initialization 0,  And the scope is the whole scope of the function 

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

    return 1
}

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

The returnButDefer() The expected return value is 1, But in return after , Has been defer The anonymous func Function execution , therefore t=t*10 Be performed , Last returnButDefer() Back to the top main() As the result of the 10

5: defer meet panic

​ We know , Can trigger defer What I want is to meet return( Or function body to the end ) And meet panic.

​ according to Knowledge point 2, We know ,defer meet return The situation is as follows ：

that , encounter panic when , All over the history of the association defer Linked list , And implement defer. In execution defer In the process : encounter recover Then stop panic, return recover Continue to carry on . If I don't meet recover, Go through this process defer After the list , towards stderr Throw out panic Information .