Часть 4. Надёжный кодУрок 14# go# ошибки# defer# собеседование

defer, panic, recover

LIFO, ловушки defer, защита границы обработчика

Цели главы

  • Понимать, когда выполняется defer, в каком порядке и когда вычисляются его аргументы.
  • Применять паттерн «открыл ресурс → defer закрытие» и замер времени через defer.
  • Понимать, как раскручивается стек при panic и где ставить recover.
  • Выбирать между panic и ошибкой и не попадаться в ловушку defer в цикле.

Три механизма

  • defer — отложенное выполнение. Чаще всего для очистки: закрыть файл, вернуть соединение, разблокировать мьютекс, дописать лог, замерить время.
  • panic — аварийная остановка обычного выполнения: программа говорит «дальше идти небезопасно».
  • recover — способ перехватить panic, но только по строгим правилам.

defer будешь писать часто, panic — редко, recover — ещё реже. Но без понимания механики в продакшене можно получить очень неприятное поведение.

defer: отложенный вызов

defer не выполняет вызов на месте — Go запоминает его и выполнит, когда текущая функция будет завершаться. Код после defer идёт дальше без задержек. Это как записка «перед выходом не забудь закрыть дверь»: написал — и занимаешься основной логикой.

go
package main

import "fmt"

func demoBasicDefer() {
    fmt.Println("начало")
    defer fmt.Println("[defer] конец demoBasicDefer")
    fmt.Println("продолжаем...")
}

func main() {
    demoBasicDefer()
    fmt.Println("вернулись в main")
}
stdout // вывод программы
начало
продолжаем...
[defer] конец demoBasicDefer
вернулись в main

Важное слово — «текущая функция»: отложенный вызов срабатывает при выходе из demoBasicDefer, а не в конце огромного main.

Порядок LIFO

Несколько defer выполняются в обратном порядке — LIFO (Last In, First Out): последним добавили — первым выполнили. Как стопка тарелок.

go
package main

import "fmt"

func main() {
    defer fmt.Println("[1] первый defer — выполнится последним")
    defer fmt.Println("[2] второй defer")
    defer fmt.Println("[3] третий defer — выполнится первым")
    fmt.Println("обычный код")
}
stdout // вывод программы
обычный код
[3] третий defer — выполнится первым
[2] второй defer
[1] первый defer — выполнится последним

Это не просто правило, а практичное свойство: если открыли файл, начали транзакцию и взяли блокировку, освобождать нужно в обратном порядке — блокировку, транзакцию, файл. defer делает эту очередь естественной.

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

Главная ловушка: аргументы отложенного вызова вычисляются в момент выполнения строки с defer, а не при выходе. Нужно значение на момент выхода — используй замыкание: отложенная функция прочитает переменную позже.

go
package main

import "fmt"

func demoArguments() {
    filmID := 100
    defer fmt.Println("[defer-аргумент] filmID =", filmID) // значение зафиксировано сейчас
    filmID = 200
    fmt.Println("сейчас filmID =", filmID)
}

func demoClosure() {
    viewCount := 500
    defer func() {
        fmt.Println("[defer-замыкание] viewCount =", viewCount) // читается при выходе
    }()
    viewCount = 999
    fmt.Println("сейчас viewCount =", viewCount)
}

func main() {
    demoArguments()
    demoClosure()
}
stdout // вывод программы
сейчас filmID = 200
[defer-аргумент] filmID = 100
сейчас viewCount = 999
[defer-замыкание] viewCount = 999

Зачем defer в реальном коде

Открыл ресурс → сразу defer закрытие

Самый частый паттерн: создал ресурс и сразу рядом написал его закрытие. Не в конце функции и не в каждой ветке, а прямо у места, где ресурс появился. Если ниже будет return из-за ошибки — файл закроется. Добавят ещё одну ветку выхода — тоже закроется. Поэтому defer повсюду в коде с файлами, соединениями, транзакциями и мьютексами.

go
package main

import (
    "fmt"
    "os"
)

func writeToTempFile() error {
    file, err := os.CreateTemp("", "goflix-catalog-*.txt")
    if err != nil {
        return fmt.Errorf("создание файла: %w", err)
    }
    defer os.Remove(file.Name()) // выполнится вторым: удалить файл
    defer func() {               // выполнится первым: закрыть файл
        if err := file.Close(); err != nil {
            fmt.Println("ошибка закрытия:", err)
            return
        }
        fmt.Println("файл закрыт")
    }()

    fmt.Println("файл создан")
    if _, err := file.WriteString("GoFlix catalog data"); err != nil {
        return fmt.Errorf("запись: %w", err) // файл всё равно закроется и удалится
    }
    fmt.Println("данные записаны")
    return nil
}

func main() {
    if err := writeToTempFile(); err != nil {
        fmt.Println("ошибка:", err)
    }
}
stdout // вывод программы
файл создан
данные записаны
файл закрыт

Обрати внимание на порядок: сначала нужно закрыть файл, потом удалить. Из-за LIFO Remove ставим раньше, Close — позже. Закрытие обёрнуто в функцию, чтобы проверить ошибку Close.

Замер времени одной строкой

Тот же принцип «аргументы вычисляются сразу» даёт красивый приём: time.Now() вызывается в начале функции и фиксирует старт, а trackTime выполнится в конце и посчитает разницу. Профилировщик это не заменит, но для локальной диагностики удобно.

go
package main

import (
    "fmt"
    "time"
)

func trackTime(start time.Time, name string) {
    fmt.Printf("%s: %v\n", name, time.Since(start).Round(10*time.Millisecond))
}

func loadMovieCatalog() {
    defer trackTime(time.Now(), "загрузка каталога") // time.Now() вычислится сразу
    time.Sleep(80 * time.Millisecond)
    fmt.Println("каталог загружен")
}

func main() {
    loadMovieCatalog()
    // недетерминированный вывод: время зависит от машины
}

Пример вывода:

text
каталог загружен
загрузка каталога: 80ms

panic

panic — аварийная остановка обычного выполнения текущей горутины. Go не обрывает программу мгновенно: он раскручивает стек и выполняет все defer — сначала в функции, где случилась паника, потом в вызвавшей, и так вверх. Если паника нигде не перехвачена, программа завершается с сообщением и стеком вызовов.

go
package main

import "fmt"

func startEpisodePlayback() {
    defer fmt.Println("[defer playback] закрываем буфер")
    fmt.Println("стартуем воспроизведение")
    panic("битый файл эпизода")
}

func demoPanicFlow() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("[recover] паника перехвачена:", r)
        }
    }()
    defer fmt.Println("[defer demoPanicFlow] освобождаем контекст запроса")

    startEpisodePlayback()
    fmt.Println("эта строка не выполнится")
}

func main() {
    demoPanicFlow()
    fmt.Println("main продолжает работу")
}
stdout // вывод программы
стартуем воспроизведение
[defer playback] закрываем буфер
[defer demoPanicFlow] освобождаем контекст запроса
[recover] паника перехвачена: битый файл эпизода
main продолжает работу

defer выполняется не только при обычном return, но и во время паники. Поэтому он и хорош для очистки: даже когда всё пошло не по плану, ресурс можно аккуратно освободить.

Без recover программа падает:

go
package main

func main() {
    panic("битый файл эпизода") // ожидается panic
}
text
panic: битый файл эпизода

goroutine 1 [running]:
main.main()
exit status 2

recover

recover — встроенная функция, которая останавливает панику и возвращает её значение. Жёсткое правило: она работает только внутри отложенной функции. В обычном коде recover() вернёт nil и ничего не перехватит.

Защитная обёртка: если переданная функция отработала нормально — вернём «успешно»; если внутри паника — отложенная функция перехватит её и запишет результат в именованный результат result.

go
package main

import "fmt"

func safeExecute(name string, fn func()) (result string) {
    defer func() {
        if r := recover(); r != nil {
            result = fmt.Sprintf("%s: паника перехвачена: %v", name, r) // меняем именованный результат
        }
    }()
    fn()
    return name + ": успешно"
}

func main() {
    fmt.Println(safeExecute("request-41", func() {}))
    fmt.Println(safeExecute("request-42", func() {
        panic("кэш рекомендаций повреждён")
    }))
    fmt.Println("программа продолжает работу")
}
stdout // вывод программы
request-41: успешно
request-42: паника перехвачена: кэш рекомендаций повреждён
программа продолжает работу

Где recover нужен на практике: граница обработчика

Типичный сценарий — сервер: один запрос не должен положить весь процесс. recover ставят на границе системы и превращают панику в обычную ошибку.

go
package main

import "fmt"

func handleRequest(movieTitle string) (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("внутренняя ошибка обработчика: %v", r)
        }
    }()
    if movieTitle == "" {
        panic("movieTitle пустой после валидации") // имитируем внутренний баг
    }
    fmt.Printf("запрос обработан: %q\n", movieTitle)
    return nil
}

func main() {
    for _, title := range []string{"Матрица", ""} {
        if err := handleRequest(title); err != nil {
            fmt.Println("ошибка:", err)
        }
    }
    fmt.Println("сервер продолжает принимать запросы")
}
stdout // вывод программы
запрос обработан: "Матрица"
ошибка: внутренняя ошибка обработчика: movieTitle пустой после валидации
сервер продолжает принимать запросы

В реальном коде пустое название от пользователя вернули бы обычной ошибкой; здесь паника имитирует внутренний баг — данные должны были быть проверены выше. recover — не замена обработке ошибок, а страховка на границах: HTTP-middleware, воркер, consumer очереди, планировщик задач — там, где одна авария не должна уронить весь сервис.

panic или ошибка

Короткий ответ: почти всегда ошибка. Пример: посчитать среднее время просмотра, а зрителей ноль. Ноль может прийти из ввода пользователя, из базы, из неудачного фильтра — ситуация неприятная, но ожидаемая. Значит, это ошибка:

go
func averageWatchTime(totalMinutes, viewers int) (int, error) {
    if viewers == 0 {
        return 0, errors.New("количество зрителей равно нулю")
    }
    return totalMinutes / viewers, nil
}
Ошибка error panic
Ожидаемая ситуация, с которой можно работать Баг или нарушенный инвариант: продолжать небезопасно
Файл не найден, пользователь ввёл мусор, сеть отвалилась, таймаут, нет доступа, запись не прошла валидацию nil там, где он по логике невозможен; индекс за границей из-за ошибки в коде; ветка switch, недостижимая по бизнес-логике; на старте не загрузился обязательный конфиг

Если сомневаешься — выбирай ошибку.

defer в цикле — ловушка

defer срабатывает при выходе из функции, а не из итерации цикла. В цикле отложенные вызовы копятся до конца функции — файлы, соединения или блокировки держатся дольше, чем нужно. На трёх файлах не страшно, на тысяче — очень неприятно. Правильный вариант — вынести тело итерации в отдельную функцию.

go
package main

import "fmt"

func badDeferInLoop(files []string) {
    for _, name := range files {
        fmt.Println("открыли", name)
        defer fmt.Println("закрыли", name) // копится до конца функции
    }
    fmt.Println("конец функции")
}

func processFile(name string) {
    fmt.Println("открыли", name)
    defer fmt.Println("закрыли", name) // сработает при выходе из processFile
    fmt.Println("обработали", name)
}

func main() {
    files := []string{"catalog.json", "users.json"}
    badDeferInLoop(files)
    fmt.Println("---")
    for _, name := range files {
        processFile(name)
    }
}
stdout // вывод программы
открыли catalog.json
открыли users.json
конец функции
закрыли users.json
закрыли catalog.json
---
открыли catalog.json
обработали catalog.json
закрыли catalog.json
открыли users.json
обработали users.json
закрыли users.json

recover работает только в своей горутине

Паника перехватывается только в той горутине, где она случилась. Если воркер запущен в отдельной горутине, recover в main его не спасёт — и упадёт вся программа. Защитную обёртку ставят внутри самой горутины:

go
go func() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("воркер упал: %v", r)
        }
    }()
    process(job)
}()

Про горутины — в 17 — Конкурентность — горутины и каналы.

Практика

Домашнее задание: устойчивая загрузка каталога

Каждый день поставщики присылают пачку JSON-файлов с фильмами, бэкенд читает их и собирает общий список. Один битый файл не должен валить весь процесс. Напиши функцию:

go
type Movie struct {
    Name string
    Year int
}

func loadCatalog(files []string) ([]Movie, error)

Примеры файлов:

json
// movies_valid.json
[
    {"Name": "Blade Runner 2049", "Year": 2017},
    {"Name": "Dune", "Year": 2021}
]
// movies_broken.json — обрезан посередине
[
    {"Name": "Tenet", "Year": 2020},
    {"Name": "Oppenheimer", "Year":
// movies_empty.json
[]

Требования:

  1. Замеряй время выполнения функции.
  2. Освобождай каждый файл сразу после работы с ним.
  3. Защитись от panic и передавай её содержимое наверх через именованный результат-ошибку.
  4. Добавляй контекст ко всем ошибкам через %w.
решениеЭталонное решение
go
package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "os"
    "path/filepath"
    "time"
)

type Movie struct {
    Name string
    Year int
}

// normalize имитирует код поставщика, который может паниковать.
func normalize(m Movie) Movie {
    if m.Name == "" {
        panic("пустое название фильма")
    }
    return m
}

func loadFile(path string) (movies []Movie, err error) {
    defer func() {
        if r := recover(); r != nil {
            movies = nil
            err = fmt.Errorf("файл %s: паника: %v", filepath.Base(path), r)
        }
    }()

    f, err := os.Open(path)
    if err != nil {
        return nil, fmt.Errorf("открытие %s: %w", filepath.Base(path), err)
    }
    defer f.Close() // файл закроется сразу после обработки, а не в конце loadCatalog

    var raw []Movie
    if err := json.NewDecoder(f).Decode(&raw); err != nil {
        return nil, fmt.Errorf("разбор %s: %w", filepath.Base(path), err)
    }
    for _, m := range raw {
        movies = append(movies, normalize(m))
    }
    return movies, nil
}

func loadCatalog(files []string) ([]Movie, error) {
    defer func(start time.Time) {
        fmt.Printf("загрузка каталога заняла %v\n", time.Since(start).Round(time.Second))
    }(time.Now())

    var all []Movie
    var errs []error
    for _, path := range files {
        movies, err := loadFile(path)
        if err != nil {
            errs = append(errs, err) // битый файл не валит весь процесс
            continue
        }
        all = append(all, movies...)
    }
    return all, errors.Join(errs...)
}

func main() {
    dir, err := os.MkdirTemp("", "goflix-catalog")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer os.RemoveAll(dir)

    samples := []struct{ name, data string }{
        {"movies_valid.json", `[{"Name": "Dune", "Year": 2021}, {"Name": "Arrival", "Year": 2016}]`},
        {"movies_broken.json", `[{"Name": "Tenet", "Year": 2020}, {"Name": "Oppenheimer", "Year":`},
        {"movies_empty.json", `[]`},
        {"movies_panic.json", `[{"Name": "", "Year": 2020}]`},
    }
    var paths []string
    for _, s := range samples {
        p := filepath.Join(dir, s.name)
        if err := os.WriteFile(p, []byte(s.data), 0o644); err != nil {
            fmt.Println(err)
            return
        }
        paths = append(paths, p)
    }

    movies, err := loadCatalog(paths)
    fmt.Println("загружено:", movies)
    if err != nil {
        fmt.Println("ошибки:")
        fmt.Println(err)
    }
}
stdout // вывод программы
загрузка каталога заняла 0s
загружено: [{Dune 2021} {Arrival 2016}]
ошибки:
разбор movies_broken.json: unexpected EOF
файл movies_panic.json: паника: пустое название фильма

Тренировка: предскажи вывод

go
package main

import "fmt"

func f() (n int) {
    defer func() { n *= 2 }()
    n = 3
    return n + 1
}

func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Print(i, " ")
    }
    fmt.Println(f())
}
самопроверкаОтвет
text
8
2 1 0

return n + 1 записывает 4 в именованный результат, затем defer удваивает его — получается 8. Отложенные Print из цикла выполнятся при выходе из main в обратном порядке, а аргумент i каждого из них был зафиксирован в момент defer.

Проверь себя

вопросКогда выполняется отложенный вызов и в каком порядке, если их несколько?

При выходе из текущей функции — и при return, и при панике. Несколько defer выполняются в обратном порядке (LIFO).

вопросКогда вычисляются аргументы defer fmt.Println(x)?

Сразу, в момент выполнения строки с defer. Чтобы прочитать значение при выходе, используют замыкание: defer func() { fmt.Println(x) }().

вопросПочему defer f.Close() пишут сразу после успешного открытия файла?

Чтобы файл закрылся при любом выходе из функции — при любом return и при панике — и чтобы очистка была рядом с захватом ресурса.

вопросЧто происходит при panic?

Обычное выполнение горутины останавливается, стек раскручивается и выполняются все defer по пути вверх. Если паника не перехвачена, программа завершается с сообщением и стеком вызовов.

вопросГде и как работает recover?

Только внутри отложенной функции и только для паники в той же горутине. Возвращает значение паники и останавливает её; функция при этом завершается, а не продолжается с места паники.

вопросКогда использовать panic, а когда ошибку?

Ошибку — для ожидаемых ситуаций: ввод, сеть, файлы, валидация, таймауты. panic — для багов и нарушенных инвариантов, например отсутствия обязательного конфига на старте. Сомневаешься — ошибка.

вопросЧто не так с defer внутри цикла?

Отложенные вызовы копятся до выхода из функции, и ресурсы держатся дольше нужного. Тело итерации выносят в отдельную функцию.


Ключевые выводы

  • ⏳ defer выполняется при выходе из функции — и при return, и при панике.
  • 🥞 Несколько defer — в обратном порядке (LIFO), удобно для освобождения ресурсов.
  • 📌 Аргументы defer вычисляются сразу; для значения на момент выхода — замыкание.
  • 🧹 Паттерн: захватил ресурс → сразу defer освобождение.
  • 🚨 panic раскручивает стек; recover работает только в defer и только в своей горутине.
  • ⚖️ Почти всегда — ошибка, а не паника; recover ставят на границах: обработчики, воркеры.
// связанные темы и шпаргалки