defer schedules a function to run before the surrounding function returns, executing in last-in, first-out (LIFO) order; 2. arguments to deferred functions are evaluated immediately, but the function runs later, though closures can capture variables by reference for delayed evaluation; 3. common use cases include closing files, unlocking mutexes, and cleaning up temporary resources, ensuring these actions occur regardless of how the function exits; 4. deferred functions can modify named return values via closures and execute even during panics, making them ideal for use with recover to handle errors gracefully; in summary, defer provides a reliable mechanism for cleanup and resource management in Go, ensuring that critical final actions are performed.

In Go, defer is a keyword that allows you to schedule a function call to run just before the surrounding function returns. It's commonly used for cleanup actions like closing files, unlocking mutexes, or logging exit from a function.

1. Basic Behavior of defer

When you use defer, the function call is pushed onto a stack and executed in last-in, first-out (LIFO) order when the function exits — whether it exits normally or due to a panic.

func main() {
    defer fmt.Println("First deferred")
    defer fmt.Println("Second deferred")
    fmt.Println("Inside main")
}

Output:

Inside main
Second deferred
First deferred

Notice: The second defer runs first because deferred calls are stacked.

2. When Is the Deferred Function Evaluated?

An important detail: the arguments to the deferred function are evaluated immediately when defer is encountered, but the function itself runs later.

func main() {
    i := 10
    defer fmt.Println("Value of i:", i) // prints 10, not 20
    i = 20
}

Output:

Value of i: 10

Even though i changes later, the value was captured at the time defer was executed.

You can use a closure to delay evaluation:

func main() {
    i := 10
    defer func() {
        fmt.Println("Value of i:", i) // prints 20
    }()
    i = 20
}

Now it prints 20 because the closure captures the variable by reference.

3. Common Use Cases

defer shines in resource management:

? Closing a file

file, err := os.Open("data.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close() // Guaranteed to run before function exits

// ... use the file

? Unlocking a mutex

mu.Lock()
defer mu.Unlock()

// Critical section
// Even if panic occurs, Unlock will be called

? Clean up temporary resources

os.MkdirAll("/tmp/work", 0755)
defer os.RemoveAll("/tmp/work") // Cleanup at the end

4. Interaction with Named Return Values and panic/recover

If a function has named return values, a deferred function can modify them using a closure.

func weird() (result int) {
    defer func() {
        result  = 10
    }()
    return 5 // returns 15
}

Also, defer runs even if there's a panic:

func panicky() {
    defer fmt.Println("This runs even after panic")
    panic("oh no!")
}

And this makes defer perfect for recover:

func safeDivide(a, b int) (result int, ok bool) {
    defer func() {
        if r := recover(); r != nil {
            result = 0
            ok = false
        }
    }()
    result = a / b
    ok = true
    return
}

Summary

• defer schedules a function call to run when the function exits.
• Arguments are evaluated immediately; function runs later.
• Multiple defers run in LIFO order.
• Useful for cleanup: files, locks, temp data.
• Works with panic and recover.
• Can modify named return values via closures.

It’s not magic — just a clean, reliable way to ensure cleanup code runs. Use it often when managing resources.

Basically, if you open it, lock it, or create it — defer the close, unlock, or cleanup.

The above is the detailed content of How does defer work in Golang?. For more information, please follow other related articles on the PHP Chinese website!