Defer в Go: как работает отложенный вызов, где он реально спасает код и на чём чаще всего ошибаются

defer file.Close()

Что такое defer в Go

defer fmt.Println("done")

defer = выполнить этот вызов перед выходом из функции

Первый пример defer

package main
import "fmt"
func main() {
fmt.Println("start")
defer fmt.Println("deferred")
fmt.Println("end")
}

start
end
deferred

Почему так происходит

Зачем defer вообще нужен

Почему defer любят в Go-коде

f, err := os.Open("data.txt")
if err != nil {
return err
}
// работа с файлом
err = f.Close()
if err != nil {
return err
}

f, err := os.Open("data.txt")
if err != nil {
return err
}
defer f.Close()
// работа с файлом

Полезная ментальная модель

Когда выполняется defer

Что значит “при выходе из функции”

package main
import "fmt"
func demo() {
defer fmt.Println("defer")
fmt.Println("before return")
return
}
func main() {
demo()
}

before return
defer

Defer относится к конкретной функции

func main() {
if true {
defer fmt.Println("inside if")
}
fmt.Println("main body")
}

main body
inside if

Самая частая ошибка понимания

Почему defer работает в обратном порядке: LIFO

package main
import "fmt"
func main() {
defer fmt.Println("first")
defer fmt.Println("second")
defer fmt.Println("third")
fmt.Println("body")
}

body
third
second
first

Почему это вообще логично

Где это реально полезно

lockA()
defer unlockA()
lockB()
defer unlockB()

Defer и return: что выполняется раньше

package main
import "fmt"
func test() int {
defer fmt.Println("defer")
return 10
}
func main() {
fmt.Println(test())
}

defer
10

Почему вывод именно такой

Defer не отменяет return

Полезный шаблон мышления

Аргументы defer вычисляются сразу

Пример с числом

package main
import "fmt"
func main() {
x := 10
defer fmt.Println(x)
x = 20
}

10

Почему так происходит

defer fmt.Println(x)

Где на этом реально ошибаются

defer logDuration(startTime)

Как получить новое значение

package main
import "fmt"
func main() {
x := 10
defer func() {
fmt.Println(x)
}()
x = 20
}

20

Почему с анонимной функцией уже иначе

Захват переменной и defer

defer fmt.Println(x)

defer func() {
fmt.Println(x)
}()

Named return и как defer может менять результат

package main
import "fmt"
func test() (result int) {
defer func() {
result++
}()
return 10
}
func main() {
fmt.Println(test())
}

11

Почему не 10

Что такое named return простыми словами

func test() (result int)

Где это полезно

Когда named return ухудшает читаемость

func calc() (result int) {
defer func() { result++ }()
return 5
}

func calc() int {
result := 5
result++
return result
}

Что спрашивают на собеседовании

func f() (x int) {
defer func() { x++ }()
return 1
}

Где defer реально нужен: Close, Unlock, cleanup

Закрытие файла

package main
import (
"os"
)
func readFile() error {
f, err := os.Open("data.txt")
if err != nil {
return err
}
defer f.Close()
// работа с файлом
return nil
}

Unlock mutex

mu.Lock()
defer mu.Unlock()
// критическая секция

Закрытие http.Response.Body

resp, err := http.Get("https://example.com")
if err != nil {
return err
}
defer resp.Body.Close()

Закрытие sql.Rows

rows, err := db.Query("SELECT id FROM users")
if err != nil {
return err
}
defer rows.Close()

Cleanup как стиль мышления

открыл ресурс -> сразу подумал, как он будет освобождён

Паттерн, который стоит унести в работу

Но defer не всегда обязателен

Небольшая история из практики

Опасная ловушка: defer в цикле

В чём проблема

for _, name := range files {
f, err := os.Open(name)
if err != nil {
return err
}
defer f.Close()
// работа с файлом
}

Почему это опасно

Когда defer в цикле допустим

Правильный вариант через отдельную функцию

func processFile(name string) error {
f, err := os.Open(name)
if err != nil {
return err
}
defer f.Close()
// работа с файлом
return nil
}
func main() {
for _, name := range files {
if err := processFile(name); err != nil {
// обработка ошибки
}
}
}

Альтернатива без defer

for _, name := range files {
f, err := os.Open(name)
if err != nil {
return err
}
// работа с файлом
f.Close()
}

Panic, recover и defer

Почему recover работает именно через defer

package main
import "fmt"
func safe() {
defer func() {
if r := recover(); r != nil {
fmt.Println("panic recovered:", r)
}
}()
panic("boom")
}
func main() {
safe()
fmt.Println("program continues")
}

panic recovered: boom
program continues

Что здесь происходит пошагово

Почему recover вне defer не поможет

r := recover()
fmt.Println(r)

Важный практический нюанс

Где это реально используют

Чего не надо делать

Производительность: дорогой ли defer

Нужно ли бояться defer из-за скорости

Где вопрос производительности всё же может всплывать

Нормальное правило взрослого кода

Частые ошибки новичков и вопросы на собеседовании

Что любят спрашивать на собеседовании

Практика: 6 коротких упражнений по defer в Golang

Упражнение 1. Один defer

start
work
done

Упражнение 2. Несколько defer

Упражнение 3. Аргументы вычисляются сразу

Упражнение 4. Анонимная функция

Упражнение 5. Defer и named return

Упражнение 6. Defer в цикле

Шпаргалка по defer в Golang

Мини-шаблоны, которые стоит унести в работу

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

mu.Lock()
defer mu.Unlock()

resp, err := http.Get(url)
if err != nil {
return err
}
defer resp.Body.Close()

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

Как самому проверить, что тема реально улеглась

Зачем вообще хорошо понимать defer, если он кажется маленькой фишкой