Какие знаешь нюансы при работе с Closures?

Нюансы работы с Closures в Swift

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

1. Захват переменных и семантика копирования

Замыкания захватывают переменные из окружающего контекста. Для значимых типов (value types) по умолчанию создаётся неизменяемая копия. Для её модификации нужно использовать capture list с var.

var counter = 0
let closure = { [counter] in
    print(counter) // Захватывается значение на момент создания замыкания
}
counter = 5
closure() // Выведет 0, а не 5

Для модификации внешней переменной внутри замыкания используется захват по ссылке с inout или через обёртку (например, класс).

2. Сильные ссылки и циклы удержания

Самый критичный нюанс — циклы сильных ссылок (strong reference cycles) при захвате self или других ссылочных типов. Если объект (например, класс) хранит замыкание как свойство, а замыкание захватывает self сильно, возникает взаимное удержание и утечка памяти.

class DataManager {
    var dataHandler: (() -> Void)?
    
    func setupHandler() {
        // ПЛОХО: Сильный захват self -> цикл удержания
        dataHandler = {
            self.processData() // self удерживается замыканием
        }
    }
    
    func processData() { }
}

Решение: Использовать capture list с weak или unowned.

func setupHandler() {
    dataHandler = { [weak self] in
        guard let self = self else { return }
        self.processData()
    }
}

3. Автозамыкания (Autoclosures) и отложенное выполнение

Автозамыкание — замыкание, которое автоматически создаётся для оборачивания выражения. Позволяет откладывать вычисление выражения до момента вызова замыкания.

func logIfTrue(_ condition: @autoclosure () -> Bool) {
    if condition() { // Вычисление происходит только здесь
        print("True")
    }
}

logIfTrue(2 > 1) // Передаётся не bool, а замыкание, возвращающее bool

Используется в стандартной библиотеке для операторов &&, ||, а также в assert() для исключения вычислений в production.

4. Утечки в escaping-замыканиях

Замыкания, которые переживают область видимости функции (escaping closures), требуют особого внимания. По умолчанию замыкания в Swift 3+ являются non-escaping. Для escaping-замыканий нужно явно указывать @escaping.

func fetchData(completion: @escaping (Result<Data, Error>) -> Void) {
    URLSession.shared.dataTask { data, _, error in
        // completion вызывается асинхронно -> escaping обязательно
        completion(.success(data!))
    }.resume()
}

Важно: В escaping-замыканиях для захвата self нужно явно использовать self. (компилятор требует), что напоминает о потенциальном цикле удержания.

5. Изменяемые захваты (mutable captures) для value-типов

Даже если внешняя переменная объявлена как var, по умолчанию захваченная копия внутри замыкания неизменяема. Для модификации нужно использовать var в capture list.

var count = 0
let incrementer = { [var count] in // Теперь count внутри замыкания — изменяемая копия
    count += 1
    return count
}
print(incrementer()) // 1
print(count) // 0 (оригинал не изменился)

6. Влияние на производительность

• Non-escaping замыкания могут быть оптимизированы компилятором (например, инлайнинг), так как их время жизни известно.
• Захват по ссылке (reference types) дешевле, чем копирование больших структур, но требует управления памятью.
• Использование [weak self] добавляет накладные расходы на проверку nil.

7. Синтаксические сокращения и неявные параметры

Swift предоставляет множество синтаксических удобств, которые могут запутать новичков:

let numbers = [1, 2, 3]
// Полная форма
let squared = numbers.map({ (number: Int) -> Int in
    return number * number
})
// Сокращённая форма с неявными параметрами
let squaredShort = numbers.map { $0 * $0 }

8. Замыкания и параллелизм (concurrency)

С появлением async/await в Swift 5.5 многие escaping-замыкания для завершения асинхронных операций устарели. Однако замыкания остаются важны для:

• Task.init и Task.detached для запуска конкурентных задач.
• Actor isolation — замыкания внутри акторов могут захватывать изолированные данные.
• @Sendable замыкания — ограничение, гарантирующее безопасную передачу замыканий между потоками в конкурентном коде.

func performConcurrently() async {
    await Task {
        // Это замыкание изолировано от актора
        let result = heavyCalculation()
        print(result)
    }.value
}

Практические рекомендации

1. Всегда анализируйте жизненный цикл замыкания — будет ли оно escaping.
2. Для захвата self предпочитайте [weak self], если нет гарантии, что self переживёт замыкание. Используйте [unowned self] только при полной уверенности.
3. Избегайте сильных ссылок на внешние объекты внутри замыканий, которые хранятся долго.
4. Используйте defer внутри длинных замыканий для гарантии очистки ресурсов.
5. Тестируйте с Instruments (Leaks) для выявления циклов удержания, особенно в сложных цепочках замыканий.

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