Ответ.

В Go правила области видимости переменных (scoping) строго определяются блоками ({}), а имя переменной может быть затенено (shadowing) во вложенных областях. Особенно много ловушек возникает во вложенных функциях, анонимных функциях, циклах и при объявлении переменных с тем же именем в разных уровнях.

История вопроса

Go специально минимизировал "магическое" поведение с областью видимости, чтобы сделать код читабельнее. Но гибкость синтаксиса и допускающая повторное объявление переменных через короткую форму := приводит к ошибкам восприятия.

Проблема

Если во вложенной функции или в блоке цикла объявить переменную с тем же именем, что и на верхнем уровне, внешняя переменная будет недоступна (затенена — shadowed). В большинстве случаев это не замечается компилятором и легко становится причиной ошибок, особенно при работе с closure. Ещё одна распространённая ошибка — объявление новой переменной в блоке if или в for-init, а затем попытка обратиться к ней вне блока.

Решение

Всегда следите за уровнями области видимости. Не используйте одинаковые имена переменных во вложенных блоках или анонимных функциях без реальной необходимости, избегайте коротких имён и будьте аккуратны с использованием :=.

Пример кода:

package main
import "fmt"

func main() {
    x := 1
    {
        x := 2 // затеняет x из main()
        fmt.Println("Inner x:", x)
    }
    fmt.Println("Outer x:", x)

    for i := 0; i < 3; i++ {
        x := i // создаётся новый x на каждой итерации
        go func() {
            fmt.Println("Goroutine x:", x)
        }()
    }
}

В этом примере внешняя переменная x не изменяется, а новое x создаётся внутри блока. Во втором цикле переменная x захватывается во вложенной функции — результат может быть неожиданным.

Ключевые особенности:

Каждая область (блок) может затенять переменные верхнего уровня;
Два объявления переменной с одним именем не связаны между собой, если находятся в разных областях;
Closure захватывают переменную, а не её значение на момент итерации;
Короткая форма := внутри блока всегда создаёт новую переменную, даже если внешняя уже есть.

Вопросы с подвохом.

1. Какое значение переменной будет напечатано последним во вложенном блоке при затенении?

Значение внешней переменной, потому что внутренняя переменная существует только в блоке.

2. Что произойдёт, если попытаться обратиться к переменной, объявленной внутри блока if/for, вне этого блока?

Компилятор выдаст ошибку: переменная вне области видимости.

if true {
    y := 5
}
fmt.Println(y) // ошибка

3. Как избежать неожиданного значения при создании goroutine в цикле по переменной?

Передавать переменную как параметр функции:

for i := 0; i < 3; i++ {
    go func(val int) {
        fmt.Println(val)
    }(i)
}

Типовые ошибки и анти-паттерны

Использовать один и тот же идентификатор на разных уровнях — теряются данные, их сложно отслеживать;
Захватывать переменные цикла в goroutine, не передавая их явно как аргумент;
Ожидать, что короткая форма := изменит уже существующую переменную (она создаст новую).

Пример из жизни

Негативный кейс

Цикл инициализирует несколько горутин для параллельной обработки, но внутри closure используется переменная цикла без передачи — все горутины работают с её "последним" значением.

Плюсы:

Лаконично, мало кода.

Минусы:

Непредсказуемое поведение, баги на проде, данные теряются.

Позитивный кейс

Передача переменной цикла как параметра closure — каждая горутина получает своё значение.