以身作則，解釋說明

defer 用於在函數返回前執行指定操作，如清理資源；參數在defer 時立即求值，函數按後進先出（LIFO）順序執行；1. 多個defer 按聲明逆序執行；2. 常用於文件關閉等安全清理；3. 可修改命名返回值；4. 即使發生panic 也會執行，適合用於recover；5. 避免在循環中濫用defer，防止資源洩漏；正確使用可提升代碼安全性和可讀性。

In Go, the defer statement is a useful feature 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 conditions.

Let's break it down with clear examples.

What defer does

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.

 func main() {
    defer fmt.Println("World")
    fmt.Println("Hello")
}

Output:

 Hello
World

Even though defer fmt.Println("World") appears first, it runs after the fmt.Println("Hello") because defer delays execution until the function returns.

Defer with function calls and arguments

One key thing: arguments to a deferred function are evaluated immediately , but the function itself runs later.

 func main() {
    i := 1
    defer fmt.Println("Deferred:", i) // i is 1 now
    i = 2
    fmt.Println("Immediate:", i) // prints 2
}

Output:

 Immediate: 2
Deferred: 1

So:

• i is evaluated when defer is encountered (value is 1).
• The fmt.Println runs later, but with the value captured at defer time.

Multiple defers: LIFO order

Deferred functions are executed in reverse order.

 func main() {
    defer fmt.Println("First deferred")
    defer fmt.Println("Second deferred")
    defer fmt.Println("Third deferred")
    fmt.Println("Normal execution")
}

Output:

 Normal execution
Third deferred
Second deferred
First deferred

This stack-like behavior is useful for nested cleanup operations.

Practical use: File handling

A common use case is closing files safely.

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

    // Use the file...
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

Even if an error occurs or the function returns early, file.Close() will be called thanks to defer .

Defer and return values

defer can even modify named return values:

 func counter() (i int) {
    defer func() {
        i // increments the named return value
    }()
    return 5 // i becomes 5, then defer adds 1 → returns 6
}

 func main() {
    fmt.Println(counter()) // Output: 6
}

This works because i is a named return value, and the deferred closure captures it by reference.

You can't do this with regular return statements unless the return value is named.

Common gotchas

• Don't defer in loops unnecessarily

   for _, file := range files {
      f, _ := os.Open(file)
      defer f.Close() // Bad: all Close() calls happen at end, may exceed file limit
  }

  Better: handle closing inside the loop or use a helper function.

• Defer runs even if panic occurs
  This makes defer perfect for recovery:

   defer func() {
      if r := recover(); r != nil {
          fmt.Println("Recovered from panic:", r)
      }
  }()

  ---

  Summary

  • defer schedules a function call to run before function returns.
  • Arguments are evaluated immediately; function runs later.
  • Multiple defers execute in reverse order (LIFO).
  • Great for cleanup: file closing, unlock, recover.
  • Can modify named return values.

  Used wisely, defer makes Go code cleaner and safer.

  Basically, if you need something done at the end — use defer .

  以上是以身作則，解釋說明的詳細內容。更多資訊請關注PHP中文網其他相關文章！