Go Defer — Find the Bug¶

f, err := os.Open(path)
if err != nil {
    return err
}
defer f.Close()

func processAll(paths []string) error {
    for _, p := range paths {
        if err := processOne(p); err != nil {
            return err
        }
    }
    return nil
}

func processOne(p string) error {
    f, err := os.Open(p)
    if err != nil {
        return err
    }
    defer f.Close()
    // ... read from f ...
    return nil
}

for _, item := range items {
    defer func(item string) { fmt.Println(item) }(item) // arg evaluated NOW
}

for _, item := range items {
    item := item
    defer func() { fmt.Println(item) }()
}

func compute() (n int) {
    n = 42
    return n
}

func compute() (n int) {
    defer func() {
        if n < 0 { // some condition
            n = 0
        }
    }()
    n = 42
    return n
}

func handlePanic() {
    if r := recover(); r != nil {
        fmt.Println("recovered:", r)
    }
}

func cleanup() {
    handlePanic() // calling handlePanic from cleanup, not directly deferred
}

func main() {
    defer cleanup()
    panic("oh no")
}

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("recovered:", r)
        }
    }()
    panic("oh no")
}

func cleanup() {
    if r := recover(); r != nil { // recover lives in the deferred function
        fmt.Println("recovered:", r)
    }
}

func main() {
    defer cleanup()
    panic("oh no")
}

log := &Logger{prefix: "info"}
defer log.Log("done")
log = &Logger{prefix: "debug"} // points to a new Logger
// Output: "info: done" (defer captured the original *Logger)

func main() {
    log := &Logger{prefix: "info"}
    snap := *log // value copy of the struct
    defer (&snap).Log("done")
    log.prefix = "debug"
    // Output: "info: done"
}

prefix := log.prefix
defer func() { fmt.Println(prefix + ": done") }()

func (s *SafePair) Both() {
    s.mu1.Lock()
    defer s.mu1.Unlock()
    s.mu2.Lock()
    defer s.mu2.Unlock()
    // ... critical section ...
}

snapshot := append([]int(nil), nums...)
defer fmt.Println(snapshot)

defer func() { fmt.Println(nums) }()
// Output: [999 2 3 4]

func run() error {
    if len(os.Args) < 2 {
        return errors.New("missing arg")
    }
    fmt.Println("arg:", os.Args[1])
    return nil
}

func main() {
    defer fmt.Println("cleanup")
    if err := run(); err != nil {
        fmt.Println(err)
        // os.Exit(1) here would still skip the defer in main, but the
        // defer has already fired? No — main hasn't returned yet.
        // Actually, the defer has been registered but the function body
        // hasn't ended. os.Exit still skips it.
        // Use os.Exit only after manually doing cleanup.
    }
}

type Counter struct{ n int }
func (c Counter) Print() { fmt.Println("n =", c.n) }

func main() {
    c := Counter{n: 1}
    defer c.Print()
    c.n = 42
}

defer func() { c.Print() }()
// prints "n = 42"

func iterate(n int) {
    for i := n; i >= 0; i-- {
        fmt.Println(i)
    }
}

func recurse(n int) {
    if n > 0 {
        recurse(n - 1)
    }
    fmt.Println(n)
}

func startWorker() {
    f, err := openFile()
    if err != nil { return }

    go func() {
        defer f.Close() // close when the goroutine ends
        time.Sleep(time.Second)
        fmt.Println(f.Read())
    }()
}

func startWorker() error {
    f, err := openFile()
    if err != nil { return err }
    defer f.Close()

    done := make(chan struct{})
    go func() {
        defer close(done)
        time.Sleep(time.Second)
        fmt.Println(f.Read())
    }()
    <-done
    return nil
}