Как работает defer в Go: разбираем на практических примерах

Разберем одну из самых интересных и часто неправильно понимаемых возможностей языка Go — оператор defer. На примере конкретного кода посмотрим, как работает эта конструкция и почему она ведет себя именно так, а не иначе.

Исходный код

package main

import "fmt"

func main() {
    fmt.Println("start")

    for i := 1; i < 4; i++ {
        defer fmt.Println(i)
    }

    fmt.Println("end")
}

Что же выведет эта программа?

Если вы новичок в Go, возможно, ожидаете, что вывод будет последовательным и предсказуемым. Но defer всегда преподносит сюрпризы! Давайте разбираться.

Вывод программы

start
end
3
2
1

Почему именно такой порядок?

1. Принцип LIFO (Last In, First Out)

Ключевое правило defer — отложенные вызовы выполняются в обратном порядке их объявления (по принципу стека). Каждый новый defer кладется на вершину стека, а при выходе из функции они извлекаются сверху вниз.

В нашем цикле:

• Итерация 1: defer fmt.Println(1) попадает в стек
• Итерация 2: defer fmt.Println(2) ложится сверху
• Итерация 3: defer fmt.Println(3) оказывается на самом верху

При выходе из main() выполнение начинается с вершины: 3, затем 2, затем 1.

2. Когда вычисляются аргументы defer?

Важный нюанс: аргументы функции в defer вычисляются в момент объявления отложенного вызова, а не в момент его выполнения.

Это значит, в что в нашем коде:

• На первой итерации i = 1, поэтому fmt.Println(1) запоминается с аргументом 1
• На второй итерации i = 2, запоминается fmt.Println(2)
• На третьей итерации i = 3, запоминается fmt.Println(3)

Даже если бы мы изменили i после defer (что невозможно в данном цикле, но возможно в других сценариях), вызовы все равно печатали бы 1, 2, 3.

3. Последовательность выполнения программы

Давайте пройдемся по шагам:

1. fmt.Println("start") — выполняется сразу
2. Цикл for — 3 раза объявляет defer, аргументы фиксируются
3. fmt.Println("end") — выполняется сразу после цикла
4. Выход из функции main() — запускаются все отложенные вызовы в обратном порядке

Практическое применение defer

Понимание defer критически важно для написания надежного Go-кода. Вот где это действительно нужно:

Очистка ресурсов

func readFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    
    defer file.Close() // закрывается при выходе из функции
    
    // работа с файлом
    return nil
}

Безопасное использование мьютексов

func safeUpdate(data map[string]int, key string, value int) {
    mu.Lock()
    defer mu.Unlock() // разблокировка гарантирована

    data[key] = value
}

Распространенные ошибки с defer в циклах

Наш пример демонстрирует правильное поведение, но что если мы хотим отложить вызов с текущим значением на потом? Иногда это приводит к неожиданностям:

// внимание: антипаттерн!
for i := 1; i < 4; i++ {
    defer func() {
        fmt.Println(i) // всегда выведет 4!
    }()
}

Почему? Потому что анонимная функция захватывает переменную i по ссылке, и к моменту выполнения defer цикл уже завершился, а i равна 4.

Решение:

for i := 1; i < 4; i++ {
    current := i // создаем локальную переменную
    defer func() {
        fmt.Println(current)
    }()
}

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

Оператор defer — это мощный инструмент в арсенале Go-разработчика, который обеспечивает чистоту и надежность кода. Главное помнить 3 ключевых принципа:

1. Отложенные вызовы выполняются в обратном порядке (LIFO)
2. Аргументы вычисляются в момент объявления defer
3. defer выполняется при выходе из функции, даже при панике

Понимание этих правил поможет избежать многих подводных камней и писать более качественный и поддерживаемый код на Go.

А какие интересные случаи использования defer встречались вам на практике? Делитесь в комментариях!