Цели главы
- Понимать, когда выполняется
defer, в каком порядке и когда вычисляются его аргументы. - Применять паттерн «открыл ресурс →
deferзакрытие» и замер времени черезdefer. - Понимать, как раскручивается стек при
panicи где ставитьrecover. - Выбирать между
panicи ошибкой и не попадаться в ловушкуdeferв цикле.
Три механизма
defer— отложенное выполнение. Чаще всего для очистки: закрыть файл, вернуть соединение, разблокировать мьютекс, дописать лог, замерить время.panic— аварийная остановка обычного выполнения: программа говорит «дальше идти небезопасно».recover— способ перехватитьpanic, но только по строгим правилам.
defer будешь писать часто, panic — редко, recover — ещё реже. Но без понимания механики в продакшене можно получить очень неприятное поведение.
defer: отложенный вызов
defer не выполняет вызов на месте — Go запоминает его и выполнит, когда текущая функция будет завершаться. Код после defer идёт дальше без задержек. Это как записка «перед выходом не забудь закрыть дверь»: написал — и занимаешься основной логикой.
package main
import "fmt"
func demoBasicDefer() {
fmt.Println("начало")
defer fmt.Println("[defer] конец demoBasicDefer")
fmt.Println("продолжаем...")
}
func main() {
demoBasicDefer()
fmt.Println("вернулись в main")
}начало
продолжаем...
[defer] конец demoBasicDefer
вернулись в mainВажное слово — «текущая функция»: отложенный вызов срабатывает при выходе из demoBasicDefer, а не в конце огромного main.
Порядок LIFO
Несколько defer выполняются в обратном порядке — LIFO (Last In, First Out): последним добавили — первым выполнили. Как стопка тарелок.
package main
import "fmt"
func main() {
defer fmt.Println("[1] первый defer — выполнится последним")
defer fmt.Println("[2] второй defer")
defer fmt.Println("[3] третий defer — выполнится первым")
fmt.Println("обычный код")
}обычный код
[3] третий defer — выполнится первым
[2] второй defer
[1] первый defer — выполнится последнимЭто не просто правило, а практичное свойство: если открыли файл, начали транзакцию и взяли блокировку, освобождать нужно в обратном порядке — блокировку, транзакцию, файл. defer делает эту очередь естественной.
Аргументы вычисляются сразу
Главная ловушка: аргументы отложенного вызова вычисляются в момент выполнения строки с defer, а не при выходе. Нужно значение на момент выхода — используй замыкание: отложенная функция прочитает переменную позже.
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()
}сейчас filmID = 200
[defer-аргумент] filmID = 100
сейчас viewCount = 999
[defer-замыкание] viewCount = 999Зачем defer в реальном коде
Открыл ресурс → сразу defer закрытие
Самый частый паттерн: создал ресурс и сразу рядом написал его закрытие. Не в конце функции и не в каждой ветке, а прямо у места, где ресурс появился. Если ниже будет return из-за ошибки — файл закроется. Добавят ещё одну ветку выхода — тоже закроется. Поэтому defer повсюду в коде с файлами, соединениями, транзакциями и мьютексами.
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)
}
}файл создан
данные записаны
файл закрытОбрати внимание на порядок: сначала нужно закрыть файл, потом удалить. Из-за LIFO Remove ставим раньше, Close — позже. Закрытие обёрнуто в функцию, чтобы проверить ошибку Close.
Замер времени одной строкой
Тот же принцип «аргументы вычисляются сразу» даёт красивый приём: time.Now() вызывается в начале функции и фиксирует старт, а trackTime выполнится в конце и посчитает разницу. Профилировщик это не заменит, но для локальной диагностики удобно.
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()
// недетерминированный вывод: время зависит от машины
}Пример вывода:
каталог загружен
загрузка каталога: 80mspanic
panic — аварийная остановка обычного выполнения текущей горутины. Go не обрывает программу мгновенно: он раскручивает стек и выполняет все defer — сначала в функции, где случилась паника, потом в вызвавшей, и так вверх. Если паника нигде не перехвачена, программа завершается с сообщением и стеком вызовов.
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 продолжает работу")
}стартуем воспроизведение
[defer playback] закрываем буфер
[defer demoPanicFlow] освобождаем контекст запроса
[recover] паника перехвачена: битый файл эпизода
main продолжает работуdefer выполняется не только при обычном return, но и во время паники. Поэтому он и хорош для очистки: даже когда всё пошло не по плану, ресурс можно аккуратно освободить.
Без recover программа падает:
package main
func main() {
panic("битый файл эпизода") // ожидается panic
}panic: битый файл эпизода
goroutine 1 [running]:
main.main()
exit status 2recover
recover — встроенная функция, которая останавливает панику и возвращает её значение. Жёсткое правило: она работает только внутри отложенной функции. В обычном коде recover() вернёт nil и ничего не перехватит.
Защитная обёртка: если переданная функция отработала нормально — вернём «успешно»; если внутри паника — отложенная функция перехватит её и запишет результат в именованный результат result.
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("программа продолжает работу")
}request-41: успешно
request-42: паника перехвачена: кэш рекомендаций повреждён
программа продолжает работуГде recover нужен на практике: граница обработчика
Типичный сценарий — сервер: один запрос не должен положить весь процесс. recover ставят на границе системы и превращают панику в обычную ошибку.
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("сервер продолжает принимать запросы")
}запрос обработан: "Матрица"
ошибка: внутренняя ошибка обработчика: movieTitle пустой после валидации
сервер продолжает принимать запросыВ реальном коде пустое название от пользователя вернули бы обычной ошибкой; здесь паника имитирует внутренний баг — данные должны были быть проверены выше. recover — не замена обработке ошибок, а страховка на границах: HTTP-middleware, воркер, consumer очереди, планировщик задач — там, где одна авария не должна уронить весь сервис.
panic или ошибка
Короткий ответ: почти всегда ошибка. Пример: посчитать среднее время просмотра, а зрителей ноль. Ноль может прийти из ввода пользователя, из базы, из неудачного фильтра — ситуация неприятная, но ожидаемая. Значит, это ошибка:
func averageWatchTime(totalMinutes, viewers int) (int, error) {
if viewers == 0 {
return 0, errors.New("количество зрителей равно нулю")
}
return totalMinutes / viewers, nil
}Ошибка error |
panic |
|---|---|
| Ожидаемая ситуация, с которой можно работать | Баг или нарушенный инвариант: продолжать небезопасно |
| Файл не найден, пользователь ввёл мусор, сеть отвалилась, таймаут, нет доступа, запись не прошла валидацию | nil там, где он по логике невозможен; индекс за границей из-за ошибки в коде; ветка switch, недостижимая по бизнес-логике; на старте не загрузился обязательный конфиг |
Если сомневаешься — выбирай ошибку.
defer в цикле — ловушка
defer срабатывает при выходе из функции, а не из итерации цикла. В цикле отложенные вызовы копятся до конца функции — файлы, соединения или блокировки держатся дольше, чем нужно. На трёх файлах не страшно, на тысяче — очень неприятно. Правильный вариант — вынести тело итерации в отдельную функцию.
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)
}
}открыли catalog.json
открыли users.json
конец функции
закрыли users.json
закрыли catalog.json
---
открыли catalog.json
обработали catalog.json
закрыли catalog.json
открыли users.json
обработали users.json
закрыли users.jsonrecover работает только в своей горутине
Паника перехватывается только в той горутине, где она случилась. Если воркер запущен в отдельной горутине, recover в main его не спасёт — и упадёт вся программа. Защитную обёртку ставят внутри самой горутины:
go func() {
defer func() {
if r := recover(); r != nil {
log.Printf("воркер упал: %v", r)
}
}()
process(job)
}()Про горутины — в 17 — Конкурентность — горутины и каналы.
Практика
Домашнее задание: устойчивая загрузка каталога
Каждый день поставщики присылают пачку JSON-файлов с фильмами, бэкенд читает их и собирает общий список. Один битый файл не должен валить весь процесс. Напиши функцию:
type Movie struct {
Name string
Year int
}
func loadCatalog(files []string) ([]Movie, error)Примеры файлов:
// 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
[]Требования:
- Замеряй время выполнения функции.
- Освобождай каждый файл сразу после работы с ним.
- Защитись от
panicи передавай её содержимое наверх через именованный результат-ошибку. - Добавляй контекст ко всем ошибкам через
%w.
решениеЭталонное решение
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)
}
}загрузка каталога заняла 0s
загружено: [{Dune 2021} {Arrival 2016}]
ошибки:
разбор movies_broken.json: unexpected EOF
файл movies_panic.json: паника: пустое название фильмаТренировка: предскажи вывод
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())
}самопроверкаОтвет
8
2 1 0return 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ставят на границах: обработчики, воркеры.
