Как изменится значение переменной counter, если она используется внутри замыкания и затем вызывается после изменения её значения?

Ответ на вопрос о захвате переменной в замыкании

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

Способы захвата переменных в замыкании

1. Захват по ссылке (Reference Capture)

По умолчанию, когда вы используете переменную внутри замыкания в Swift, она захватывается по сильной ссылке. Это означает, что замыкание будет хранить ссылку на исходную переменную, а не на её значение в момент создания замыкания.

var counter = 0
let closure = {
    print("Counter внутри замыкания: \(counter)")
}

counter = 5
closure() // Выведет: Counter внутри замыкания: 5

В этом примере замыкание выводит актуальное значение counter на момент вызова, а не на момент создания замыкания. Если переменная изменяется после создания замыкания, но до его вызова, замыкание "увидит" новое значение.

2. Захват по значению (Value Capture)

Чтобы захватить значение переменной в момент создания замыкания, используется список захвата (capture list):

var counter = 0
let closure = { [counter] in
    print("Counter внутри замыкания: \(counter)")
}

counter = 10
closure() // Выведет: Counter внутри замыкания: 0

Здесь переменная counter захватывается по значению на момент создания замыкания. Последующие изменения оригинальной переменной не влияют на значение внутри замыкания.

Практические примеры с асинхронным кодом

Рассмотрим более сложный случай с асинхронным выполнением:

var counter = 0

DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
    print("Асинхронный вызов: \(counter)")
}

counter = 20
// Через 1 секунду выведет: Асинхронный вызов: 20

Здесь замыкание выполняется асинхронно, и к моменту его выполнения counter уже равен 20.

Важные нюансы поведения

Для ссылочных типов:

class CounterClass {
    var value = 0
}

var counter = CounterClass()
counter.value = 5

let closure = {
    print("Значение: \(counter.value)")
}

counter.value = 15
closure() // Выведет: Значение: 15

// Даже с захватом по значению для ссылочного типа:
let closure2 = { [counter] in
    print("Значение 2: \(counter.value)")
}

counter.value = 25
closure2() // Выведет: Значение 2: 25

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

Использование weak и unowned:

Для предотвращения циклов сильных ссылок используется weak или unowned захват:

var counter: CounterClass? = CounterClass()

let closure = { [weak counter] in
    if let counter = counter {
        print("Значение: \(counter.value)")
    } else {
        print("Объект освобождён")
    }
}

counter = nil
closure() // Выведет: Объект освобождён

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

1. По умолчанию замыкания захватывают переменные по сильной ссылке, что позволяет видеть их текущее значение при вызове.

2. Список захвата [variable] позволяет захватить значение переменной на момент создания замыкания (для value types) или слабую ссылку (для reference types).

3. Для ссылочных типов даже захват по значению в списке захвата копирует только ссылку, поэтому изменения свойств объекта будут видны.

4. В асинхронном коде поведение зависит от момента выполнения замыкания относительно изменения переменной.

5. Важно учитывать циклы удержания - сильный захват может привести к утечкам памяти.

Понимание этих механизмов критически важно для написания корректного и безопасного кода на Swift, особенно при работе с асинхронными операциями, колбэками и делегатами.