defer

Go

The behavior of defer statements is straightforward and predictable. There are three simple rules:

  1. A deferred function’s arguments are evaluated when the defer statement is evaluated. In this example, the expression “i” is evaluated when the Println call is deferred. The deferred call will print “0” after the function returns.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
    // will print:
    // 0
}

func main() {
    f := hello
    defer f()
    f = hello2
    defer f()
    // will print:
    //hello2
    //hello
}

func hello() {
	fmt.Println("hello")
}

func hello2() {
	fmt.Println("hello2")
}
  1. Deferred function calls are executed in Last In First Out order after the surrounding function returns.
    This function prints “3210”:
    1
    2
    3
    4
    5
    func b() {
        for i := 0; i < 4; i++ {
            defer fmt.Print(i)
        }
    }
  2. Deferred functions may read and assign to the returning function’s named return values.
    In this example, a deferred function increments the return value i after the surrounding function returns. Thus, this function returns 2:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    func main() {
        fmt.Println(c())
        // will print
        // 2
    }

    func c() (i int) {
        defer func() { i++ }()
        return 1
    }