defer

The defer statement is used to postpone a function call executed immediately before the surrounding function returns. The common uses of defer include releasing resources (i.e., unlock the mutex, close file handle.), do some tracing(i.e., record the running time of function), etc. E.g., an ordinary accessing global variable exclusively is like this: 

  1. var mu sync.Mutex
  2. var m = make(map[string]int)
  4. func lookup(key string) int {
  5.     mu.Lock()
  6.     v := m[key]
  7.     mu.Unlock()
  8.     return v
  9. }

An equivalent but concise format using defer is as follow: 

  1. var mu sync.Mutex
  2. var m = make(map[string]int)
  4. func lookup(key string) int {
  5.     mu.Lock()
  6.     defer mu.Unlock()
  7.     return m[key]
  8. }

You can see this style is more simpler and easier to comprehend.

The defer statements are executed in Last-In-First-Out sequence, which means the functions in latter defer statements run before their previous buddies. Check the following example: 

  1. package main
  3. import "fmt"
  5. func main()  {
  6.     defer fmt.Println("First")
  7.     defer fmt.Println("Last")
  8. }

The running result is here: 

  1. Last
  2. First

Although the function in defer statement runs very late, the parameters of the function are evaluated when the defer statement is executed. 

  1. package main
  3. import "fmt"
  5. func main()  {
  6.     i := 10
  7.     defer fmt.Println(i)
  8.     i = 100
  9. }

The running result is here: 

  1. 10

Besides, if the deferred function is a function literal, it can also modify the return value: 

  1. package main
  3. import "fmt"
  5. func modify() (result int) {
  6.     defer func(){result = 1000}()
  7.     return 100
  8. }
  10. func main()  {
  11.     fmt.Println(modify())
  12. }

The value printed is 1000, not 100.

References:
The Go Programming Language;
Defer, Panic, and Recover.