В функции отложенный вызов печатает значение переменной после её изменения. Какой порядок и значения выведе...

package main

import "fmt"

func main() {
    x := 1
    defer fmt.Println("аргумент:", x)
    defer func() {
        fmt.Println("замыкание:", x)
    }()
    x = 2
}

Краткий ответ

Программа выведет:

замыкание: 2
аргумент: 1

Отложенные вызовы выполняются в порядке LIFO: последняя зарегистрированная функция запускается первой. Аргументы обычного вызова вычисляются в момент выполнения defer, а замыкание обращается к переменной позже, поэтому видит её новое значение.

Исторический контекст

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

Различие между аргументами и замыканиями следует из общей модели Go: вызов функции с аргументами сначала вычисляет эти аргументы, тогда как замыкание сохраняет доступ к переменной и читает её при фактическом выполнении.

Постановка проблемы

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

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

Подробное решение

В выражении defer fmt.Println("аргумент:", x) значение x вычисляется сразу — в этот момент оно равно 1. Сам вызов fmt.Println откладывается, но уже вычисленные аргументы сохраняются для будущего выполнения.

В выражении defer func() { ... }() аргументов, содержащих текущее значение x, нет. Анонимная функция замыкает переменную x, а не копирует её значение при регистрации defer. После присваивания x = 2 функция при запуске читает именно 2.

Оба вызова выполняются при выходе из main. Сначала запускается второе defer, потому что отложенные вызовы образуют стек. Затем выполняется первое, использующее заранее вычисленное значение 1.

x := 1
defer fmt.Println(x)       // аргумент сохранён как 1
defer func() {             // переменная будет прочитана позже
    fmt.Println(x)
}()
x = 2

Практическое правило: если отложенный вызов должен зафиксировать состояние на текущем шаге, передавайте значение аргументом или создавайте локальную копию. Если нужно получить состояние на момент выхода, замыкание подходит лучше.

Ситуация из практики

Сервис записывает в журнал идентификатор операции при выходе из функции. Разработчик использует defer func() { log(id, status) }() и затем меняет status по мере выполнения операции. В журнале появляется итоговый статус, хотя требовался статус на момент начала этапа.

Вариант с замыканием удобен, когда нужен актуальный итоговый статус, но он опасен при ожидании снимка состояния. Вариант с передачей аргументов фиксирует значения сразу, однако не отражает последующие изменения.

Выбранное решение зависит от требования: для итоговой метрики оставляют замыкание, а для снимка используют аргументы:

startStatus := status
defer func(s string) {
    log(id, s)
}(startStatus)

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

Что кандидаты часто упускают

1. Всегда ли defer выполняется при любом выходе из функции?

Нет, defer выполняется при обычном завершении функции, при return и при выходе из функции из-за паники, пока паника не завершила программу без восстановления. При вызове os.Exit отложенные вызовы не выполняются, поскольку процесс завершается немедленно.

2. Что произойдёт, если отложенных вызовов несколько?

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

3. Можно ли изменить результат функции через замыкание в defer?

Да, если функция использует именованный возвращаемый параметр и замыкание обращается к нему. К моменту выполнения defer обычные вычисления перед return уже завершены, но отложенная функция может изменить именованный результат перед фактическим возвратом. Это отдельный эффект от времени вычисления аргументов и требует осторожности, поскольку усложняет отслеживание возвращаемого значения.