The defer Statement

Basic defer

A defer statement schedules a function call to execute just before the surrounding function returns, regardless of how it returns (including via panic). This is Go's primary tool for guaranteed cleanup code, similar to finally blocks in other languages.

Example: Basic defer

package main

import "fmt"

func greet() {
	defer fmt.Println("goodbye")
	fmt.Println("hello")
}

func main() {
	greet()
}

LIFO Order of Multiple Defers

When a function has several defer statements, they execute in last-in-first-out order: the most recently deferred call runs first. This mirrors how you'd want to unwind a stack of nested resources.

Example: LIFO Order of Multiple Defers

package main

import "fmt"

func main() {
	defer fmt.Println("first deferred (runs last)")
	defer fmt.Println("second deferred (runs middle)")
	defer fmt.Println("third deferred (runs first)")
	fmt.Println("main body")
}

Arguments Are Evaluated Immediately

A subtlety of defer is that the arguments to the deferred function are evaluated the moment the defer statement runs, not when the deferred call actually fires later -- only the call itself is postponed.

Note: If you need the latest value at return time, defer a closure instead of a plain function call.

Example: Arguments Are Evaluated Immediately

package main

import "fmt"

func main() {
	x := 1
	defer fmt.Println("deferred x was:", x) // captures x=1 now
	x = 99
	fmt.Println("current x:", x)
}

defer for Cleanup

The most common real-world use of defer is guaranteeing that a resource acquired at the start of a function -- a file, a lock, a network connection -- gets released no matter which return path the function takes.

Example: defer for Cleanup

package main

import "fmt"

func process() {
	fmt.Println("acquiring resource")
	defer fmt.Println("releasing resource")
	fmt.Println("using resource")
}

func main() {
	process()
}