Golang defer

stay Golang Use defer Often confused by the following two questions

• defer Keyword call timing and multiple calls defer How is the execution order determined ;
• defer Keyword pre calculation will be carried out when passing parameters by value , Lead to unexpected results ;

defer Is called before the current function returns , The execution order is first in then out .

Pre calculated parameters

defer It is also passed on . For example, the following code will be entered 0, Not the final 1

n := 0
defer fmt.Println(n)
n = 1

And the reason is that defer Will copy immediately defer External parameters referenced in the function , That is, run to defer fmt.Println(n) when ,n The value of is already in defer Inside the function

Even if defer Is a parametric method , It will also be copied to parameters

func TestDeferPassParmFunc(t *testing.T) {
     
	n := 0
	defer deferPassParam(n)
	n = 1
}

func deferPassParam(r int) {
     
	fmt.Println(r)
}

// output:
// 0

If we want to avoid this situation, we can defer Anonymous function or pointer parameter function

func TestDeferPassParmFunc(t *testing.T) {
    
	n := 0
	defer deferPassParam(&n)
	n = 1
}

func deferPassParam(r *int) {
    
	fmt.Println(*r)
}

// output:
// 1

common defer The phenomenon

continuity defer, First in, then out

Execute according to "first in, then out"

defer fmt.Println("one")
defer fmt.Println("two")
defer fmt.Println("three")

// output:
// three
// two
// one

defer Statement , Variable confirmation

Variable in defer It has been confirmed at the time of declaration , Even if the following variables change ,defer The actual implementation is also consistent with the declaration .

n := 0
defer fmt.Println(n)
n = 1

// output:
// 0

defer Closure , Parameters can be modified

For the named return value , By defer The function of is closure , And this function is named return value , that defer Yes, you can access the return value , And modify it

func namedReturn() (r int) {
    
	defer func() {
    
		r = 1
	}()
	return 2
}

// output
// 1

Of course , If you are defer Functions of are not closures or anonymous , But just pass in a pointer with a named return value , Actually, it's OK

func namedReturnWithDeferNamedFunc() (r int) {
     
	defer namedFuncForDer(&r)
	return 2
}

func namedFuncForDer(r *int) {
     
	*r = 1
}

// output
// 1

In addition to the special parameter named return value , Other common parameters can also be accessed and modified

//  No parameter anonymous 
n := 1
defer func() {
    
  fmt.Println(n)
}()
n = n + 1
return n
// output:
// 2

//  There are parameters anonymous 
n := 1
defer func(x int) {
    
  fmt.Println(n)
}(n)
n = n + 1
return n
// output:
// 2

summary

• defer In stack order , Define first and then execute
• defer Closure meeting in defer Execution time , Get or change variables in closures （ But do not change the unnamed return value ）
• defer Anonymous functions also get or change variables in closures （ But do not change the unnamed return value ）
• defer Ordinary function , In the case of non pointer parameters , And defer The variable values are consistent when declaring

Ref

1. https://draveness.me/golang/docs/part2-foundation/ch05-keyword/golang-defer