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

Замыкание захватывает переменную из той лексической области видимости, в которой оно создано. Если во вложенном блоке через := объявлена переменная с тем же именем, замыкание обращается к новой внутренней переменной, а не к внешней; изменения внешней переменной на него не влияют.

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

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

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

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

Затенение возникает, когда во вложенной области объявляется переменная с именем внешней. Код визуально похож на изменение существующей переменной, хотя фактически создаётся другая переменная.

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

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

При разрешении имени Go сначала ищет переменную в текущей области видимости, затем во внешних. Поэтому замыкание, созданное внутри блока после объявления внутренней переменной, захватывает именно её.

Оператор := во вложенном блоке объявляет новую переменную, даже если такое имя уже есть снаружи. В пределах одного блока := может переиспользовать существующую переменную, но только если одновременно объявляется хотя бы одна новая переменная; это правило не отменяет затенение между разными блоками.

Замыкание захватывает не снимок значения на момент создания, а переменную. Поэтому последующие присваивания этой конкретной переменной будут видны через замыкание. Внешняя переменная и внутренняя переменная с одинаковым именем являются разными объектами состояния.

package main

import "fmt"

func main() {
	x := "внешняя"
	outer := func() string { return x }
	{
		x := "внутренняя"
		inner := func() string { return x }
		x = "изменённая внутренняя"
		fmt.Println(outer())
		fmt.Println(inner())
	}
}

Программа напечатает внешняя, затем изменённая внутренняя. Первое замыкание захватило внешнюю x, второе — внутреннюю; одинаковое имя не меняет этого различия.

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

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

Сервис формирует callback для обработки запроса. Внешняя переменная содержит общую конфигурацию, а внутри цикла временная конфигурация объявляется через := с тем же именем. Callback создаётся внутри этого блока и захватывает временную переменную.

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

На практике предпочтительно использовать разные имена, например baseConfig и requestConfig, либо передавать конфигурацию параметром в функцию, создающую callback. Это делает область владения состоянием очевидной и предотвращает случайное использование не той переменной.

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

Изменится ли внешняя переменная, если замыкание изменяет одноимённую внутреннюю?

Нет. Внутренняя переменная была объявлена в другой области видимости и является отдельной переменной. Присваивание через имя внутри этого блока изменяет только её; внешняя переменная останется прежней.

Что произойдёт, если во вложенном блоке использовать = вместо :=?

Если во вложенном блоке не существует собственной переменной с этим именем, = найдёт переменную во внешней области и изменит её. Поэтому замыкание, созданное в блоке, также будет работать с внешней переменной, если отдельного внутреннего объявления нет.

Может ли замыкание использовать внутреннюю переменную после завершения блока?

Да. Область видимости ограничивает использование имени в исходном коде, но не обязана ограничивать время жизни самой переменной. Если замыкание продолжает ссылаться на неё, Go сохраняет необходимое состояние доступным; детали размещения в стеке или куче не меняют семантику программы.