Part 4. Reliable CodeLesson 14# go# errors# defer# interview

defer, panic, recover

LIFO, defer pitfalls, guarding the handler boundary

Цели главы

  • Понимать, когда выполняется 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 ставят на границах: обработчики, воркеры.

Chapter goals

  • Understand when defer runs, in what order, and when its arguments are evaluated.
  • Apply the «acquired a resource → defer its release» pattern and timing with defer.
  • Understand how the stack unwinds on panic and where to put recover.
  • Choose between panic and an error, and avoid the defer-in-a-loop trap.

Three mechanisms

  • defer — deferred execution. Most often for cleanup: close a file, return a connection, unlock a mutex, append a log line, measure time.
  • panic — an emergency stop of normal execution: the program says «going on is unsafe».
  • recover — a way to catch a panic, but only under strict rules.

You'll write defer often, panic rarely, and recover even more rarely. But without understanding the mechanics, production can spring very nasty surprises on you.

defer: a deferred call

defer doesn't run the call in place — Go remembers it and runs it when the current function is finishing. The code after defer continues without delays. It's like a note saying «don't forget to close the door on your way out»: you write it and get on with your main logic.

go
package main

import "fmt"

func demoBasicDefer() {
    fmt.Println("start")
    defer fmt.Println("[defer] end of demoBasicDefer")
    fmt.Println("continuing...")
}

func main() {
    demoBasicDefer()
    fmt.Println("back in main")
}
stdout // program output
start
continuing...
[defer] end of demoBasicDefer
back in main

The important word is «current function»: the deferred call fires when exiting demoBasicDefer, not at the end of a giant main.

LIFO order

Multiple defers run in reverse order — LIFO (Last In, First Out): the last one added is the first one executed. Like a stack of plates.

go
package main

import "fmt"

func main() {
    defer fmt.Println("[1] first defer — runs last")
    defer fmt.Println("[2] second defer")
    defer fmt.Println("[3] third defer — runs first")
    fmt.Println("normal code")
}
stdout // program output
normal code
[3] third defer — runs first
[2] second defer
[1] first defer — runs last

It's not just a rule, it's a practical property: if you opened a file, started a transaction, and took a lock, you release them in reverse order — the lock, the transaction, the file. defer makes this queue natural.

Arguments are evaluated immediately

The main trap: the arguments of a deferred call are evaluated at the moment the defer line executes, not at exit. If you need the value as of exit, use a closure: the deferred function will read the variable later.

go
package main

import "fmt"

func demoArguments() {
    filmID := 100
    defer fmt.Println("[defer argument] filmID =", filmID) // the value is captured now
    filmID = 200
    fmt.Println("filmID is now =", filmID)
}

func demoClosure() {
    viewCount := 500
    defer func() {
        fmt.Println("[defer closure] viewCount =", viewCount) // read at exit
    }()
    viewCount = 999
    fmt.Println("viewCount is now =", viewCount)
}

func main() {
    demoArguments()
    demoClosure()
}
stdout // program output
filmID is now = 200
[defer argument] filmID = 100
viewCount is now = 999
[defer closure] viewCount = 999

Why defer matters in real code

Acquire a resource → defer its release right away

The most common pattern: you create a resource and immediately, right next to it, write its release. Not at the end of the function and not in every branch, but at the spot where the resource appeared. If a return follows below because of an error — the file still gets closed. Someone adds another exit branch — it gets closed too. That's why defer is everywhere in code with files, connections, transactions, and mutexes.

go
package main

import (
    "fmt"
    "os"
)

func writeToTempFile() error {
    file, err := os.CreateTemp("", "goflix-catalog-*.txt")
    if err != nil {
        return fmt.Errorf("creating file: %w", err)
    }
    defer os.Remove(file.Name()) // runs second: remove the file
    defer func() {               // runs first: close the file
        if err := file.Close(); err != nil {
            fmt.Println("close error:", err)
            return
        }
        fmt.Println("file closed")
    }()

    fmt.Println("file created")
    if _, err := file.WriteString("GoFlix catalog data"); err != nil {
        return fmt.Errorf("writing: %w", err) // the file still gets closed and removed
    }
    fmt.Println("data written")
    return nil
}

func main() {
    if err := writeToTempFile(); err != nil {
        fmt.Println("error:", err)
    }
}
stdout // program output
file created
data written
file closed

Note the order: first close the file, then remove it. Because of LIFO, Remove is deferred first, Close second. The close is wrapped in a function so the Close error can be checked.

Timing in one line

The same «arguments are evaluated immediately» principle gives a neat trick: time.Now() is called at the start of the function and captures the beginning, while trackTime runs at the end and computes the difference. It won't replace a profiler, but it's handy for local diagnostics.

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(), "catalog loading") // time.Now() is evaluated immediately
    time.Sleep(80 * time.Millisecond)
    fmt.Println("catalog loaded")
}

func main() {
    loadMovieCatalog()
    // non-deterministic output: the time depends on the machine
}

Sample output:

text
catalog loaded
catalog loading: 80ms

panic

panic is an emergency stop of the current goroutine's normal execution. Go doesn't kill the program instantly: it unwinds the stack and runs all the defers — first in the function where the panic happened, then in its caller, and so on up. If the panic is never caught, the program terminates with a message and a stack trace.

go
package main

import "fmt"

func startEpisodePlayback() {
    defer fmt.Println("[defer playback] closing the buffer")
    fmt.Println("starting playback")
    panic("corrupted episode file")
}

func demoPanicFlow() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("[recover] panic caught:", r)
        }
    }()
    defer fmt.Println("[defer demoPanicFlow] releasing the request context")

    startEpisodePlayback()
    fmt.Println("this line never runs")
}

func main() {
    demoPanicFlow()
    fmt.Println("main keeps going")
}
stdout // program output
starting playback
[defer playback] closing the buffer
[defer demoPanicFlow] releasing the request context
[recover] panic caught: corrupted episode file
main keeps going

defer runs not only on a normal return but during a panic too. That's what makes it good for cleanup: even when everything goes wrong, the resource can be released properly.

Without recover the program crashes:

go
package main

func main() {
    panic("corrupted episode file") // panic expected
}
text
panic: corrupted episode file

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

recover

recover is a built-in function that stops a panic and returns its value. The hard rule: it works only inside a deferred function. In ordinary code recover() returns nil and catches nothing.

A safety wrapper: if the passed function completes normally — we return «ok»; if there's a panic inside — the deferred function catches it and writes the result into the named result 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: panic caught: %v", name, r) // modify the named result
        }
    }()
    fn()
    return name + ": ok"
}

func main() {
    fmt.Println(safeExecute("request-41", func() {}))
    fmt.Println(safeExecute("request-42", func() {
        panic("recommendation cache corrupted")
    }))
    fmt.Println("the program keeps running")
}
stdout // program output
request-41: ok
request-42: panic caught: recommendation cache corrupted
the program keeps running

Where recover is needed in practice: the handler boundary

A typical scenario — a server: one request must not take down the whole process. recover is placed at the boundary of the system and turns the panic into an ordinary error.

go
package main

import "fmt"

func handleRequest(movieTitle string) (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("handler internal error: %v", r)
        }
    }()
    if movieTitle == "" {
        panic("movieTitle is empty after validation") // simulating an internal bug
    }
    fmt.Printf("request handled: %q\n", movieTitle)
    return nil
}

func main() {
    for _, title := range []string{"The Matrix", ""} {
        if err := handleRequest(title); err != nil {
            fmt.Println("error:", err)
        }
    }
    fmt.Println("the server keeps accepting requests")
}
stdout // program output
request handled: "The Matrix"
error: handler internal error: movieTitle is empty after validation
the server keeps accepting requests

In real code an empty title from a user would be returned as an ordinary error; here the panic simulates an internal bug — the data should have been validated higher up. recover is not a replacement for error handling but insurance at boundaries: HTTP middleware, a worker, a queue consumer, a job scheduler — anywhere a single failure must not bring down the whole service.

panic or error

The short answer: almost always an error. Example: compute the average watch time, and the viewer count is zero. Zero can come from user input, from the database, from a bad filter — an unpleasant but expected situation. So it's an error:

go
func averageWatchTime(totalMinutes, viewers int) (int, error) {
    if viewers == 0 {
        return 0, errors.New("viewer count is zero")
    }
    return totalMinutes / viewers, nil
}
Error error panic
An expected situation you can work with A bug or a broken invariant: continuing is unsafe
File not found, garbage user input, network down, timeout, no access, a record failed validation A nil where it's logically impossible; an out-of-range index caused by a code mistake; a switch branch unreachable by business logic; a required config failing to load at startup

When in doubt — choose an error.

defer in a loop — a trap

defer fires when leaving the function, not the loop iteration. In a loop, deferred calls pile up until the end of the function — files, connections, or locks are held longer than needed. With three files it's harmless; with a thousand it's very unpleasant. The right approach is to move the iteration body into a separate function.

go
package main

import "fmt"

func badDeferInLoop(files []string) {
    for _, name := range files {
        fmt.Println("opened", name)
        defer fmt.Println("closed", name) // piles up until the end of the function
    }
    fmt.Println("end of function")
}

func processFile(name string) {
    fmt.Println("opened", name)
    defer fmt.Println("closed", name) // fires when exiting processFile
    fmt.Println("processed", name)
}

func main() {
    files := []string{"catalog.json", "users.json"}
    badDeferInLoop(files)
    fmt.Println("---")
    for _, name := range files {
        processFile(name)
    }
}
stdout // program output
opened catalog.json
opened users.json
end of function
closed users.json
closed catalog.json
---
opened catalog.json
processed catalog.json
closed catalog.json
opened users.json
processed users.json
closed users.json

recover only works in its own goroutine

A panic can only be caught in the goroutine where it happened. If a worker runs in a separate goroutine, a recover in main won't save it — and the whole program goes down. The safety wrapper goes inside the goroutine itself:

go
go func() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("worker crashed: %v", r)
        }
    }()
    process(job)
}()

More about goroutines in 17 — Concurrency — goroutines and channels.

Practice

Homework: resilient catalog loading

Every day vendors send a batch of JSON files with movies; the backend reads them and builds a combined list. One broken file must not kill the whole process. Write the function:

go
type Movie struct {
    Name string
    Year int
}

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

Sample files:

json
// movies_valid.json
[
    {"Name": "Blade Runner 2049", "Year": 2017},
    {"Name": "Dune", "Year": 2021}
]
// movies_broken.json — truncated in the middle
[
    {"Name": "Tenet", "Year": 2020},
    {"Name": "Oppenheimer", "Year":
// movies_empty.json
[]

Requirements:

  1. Measure the function's execution time.
  2. Release each file right after working with it.
  3. Protect against panic and pass its content upstream through a named error result.
  4. Add context to every error with %w.
solution
go
package main

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

type Movie struct {
    Name string
    Year int
}

// normalize simulates vendor code that can panic.
func normalize(m Movie) Movie {
    if m.Name == "" {
        panic("empty movie name")
    }
    return m
}

func loadFile(path string) (movies []Movie, err error) {
    defer func() {
        if r := recover(); r != nil {
            movies = nil
            err = fmt.Errorf("file %s: panic: %v", filepath.Base(path), r)
        }
    }()

    f, err := os.Open(path)
    if err != nil {
        return nil, fmt.Errorf("opening %s: %w", filepath.Base(path), err)
    }
    defer f.Close() // the file closes right after handling, not at the end of loadCatalog

    var raw []Movie
    if err := json.NewDecoder(f).Decode(&raw); err != nil {
        return nil, fmt.Errorf("parsing %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("catalog loading took %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) // a broken file doesn't kill the whole process
            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("loaded:", movies)
    if err != nil {
        fmt.Println("errors:")
        fmt.Println(err)
    }
}
stdout // program output
catalog loading took 0s
loaded: [{Dune 2021} {Arrival 2016}]
errors:
parsing movies_broken.json: unexpected EOF
file movies_panic.json: panic: empty movie name

Drill: predict the output

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())
}
self-check
text
8
2 1 0

return n + 1 writes 4 into the named result, then the defer doubles it — giving 8. The deferred Prints from the loop run when main exits, in reverse order, and each one's i argument was captured at the moment of the defer.

Check yourself

questionWhen does a deferred call run, and in what order when there are several?

When leaving the current function — both on return and on a panic. Multiple defers run in reverse order (LIFO).

questionWhen are the arguments of defer fmt.Println(x) evaluated?

Immediately, when the defer line executes. To read the value at exit, use a closure: defer func() { fmt.Println(x) }().

questionWhy is defer f.Close() written immediately after successfully opening a file?

So the file gets closed on any exit from the function — any return and any panic — and so the cleanup sits next to the resource acquisition.

questionWhat happens on panic?

Normal execution of the goroutine stops, the stack unwinds, and all defers on the way up run. If the panic isn't caught, the program terminates with a message and a stack trace.

questionWhere and how does recover work?

Only inside a deferred function, and only for a panic in the same goroutine. It returns the panic's value and stops it; the function then finishes rather than continuing from the panic point.

questionWhen should you use panic, and when an error?

An error — for expected situations: input, network, files, validation, timeouts. panic — for bugs and broken invariants, like a missing required config at startup. When in doubt — an error.

questionWhat's wrong with defer inside a loop?

Deferred calls pile up until the function exits, and resources are held longer than needed. Move the iteration body into a separate function.


Key takeaways

  • ⏳ defer runs when the function exits — both on return and on a panic.
  • 🥞 Multiple defers — in reverse order (LIFO), convenient for releasing resources.
  • 📌 A defer's arguments are evaluated immediately; for the value at exit — a closure.
  • 🧹 Pattern: acquired a resource → defer its release right away.
  • 🚨 panic unwinds the stack; recover works only in a defer and only in its own goroutine.
  • ⚖️ Almost always an error, not a panic; recover goes at boundaries: handlers, workers.
// related topics and cheatsheets