Что такое @escaping closure и когда его использовать?

Что такое @escaping closure

@escaping closure в Swift — это специальный атрибут, который указывает, что передаваемый в функцию closure («замыкание») может быть выполнен после завершения работы этой функции. По умолчанию все closure'ы в Swift являются non-escaping, что означает, что они должны быть исполнены строго внутри тела функции и не могут «выжить» за её пределами.

Ключевое отличие: escaping vs non-escaping

• Non-escaping closure: Замыкание, которое гарантированно исполняется внутри функции и не сохраняется для использования после её завершения. Swift может оптимизировать память для таких closure'ов, так как известно, что они не будут нужны позже.
• @escaping closure: Замыкание, которое может быть сохранено (например, в переменной, свойстве или глобальной структуре данных) и вызвано в будущем, после того как функция, принявшая его, уже завершила свою работу.

Когда использовать @escaping?

Атрибут @escaping необходимо применять, когда тело closure'а должно исполняться после завершения функции, в которую он был передан. Это происходит в нескольких распространённых сценариях:

1. Асинхронные операции и колбэки

Это самый частый случай. Когда вы передаете closure в функцию, которая запускает асинхронную задачу (например, сетевой запрос, анимацию, обработку данных в другом потоке), этот closure будет вызван только после получения ответа или завершения операции, что происходит позже завершения функции-инициатора.

func fetchData(from url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        // Этот closure исполняется позже, когда dataTask завершится.
        // Функция fetchData уже давно завершилась к этому моменту.
        if let error = error {
            completion(.failure(error))
        } else if let data = data {
            completion(.success(data))
        }
    }.resume()
    // Функция fetchData завершается сразу после запуска dataTask.resume(),
    // но closure `completion` еще не был исполнен.
}

2. Сохранение closure'а в свойстве или переменной

Если функция сохраняет передаваемый closure в свойстве класса, структуры или в глобальной переменной, этот closure потенциально может быть вызван позже, в другом месте программы.

class EventHandler {
    private var buttonTapAction: (() -> Void)? // Closure сохранен в свойстве

    func setAction(for event: Event, action: @escaping () -> Void) {
        buttonTapAction = action // Closure "escape" из функции setAction
    }

    func triggerEvent() {
        buttonTapAction?() // Closure вызывается позже, в другом методе
    }
}

3. Задержка исполнения (Dispatch)

Когда closure отправляется в очередь (DispatchQueue) для исполнения с задержкой или в другом потоке, он явно будет исполнен после текущей функции.

func performWorkLater(_ work: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
        work() // Исполнение через 1 секунду, после завершения performWorkLater
    }
}

Важные особенности и требования при работе с @escaping

• Ссылки на self: Внутри escaping closure необходимо явно указывать, как вы обращаетесь к свойствам и методам текущего экземпляра класса (self). Это часто приводит к использованию capture lists для управления зависимостью и предотвращения циклических ссылок (retain cycles).

class MyViewController {
    var data: String = ""

    func loadData() {
        fetchData(from: someURL) { [weak self] result in
            // Используем [weak self] для избежания retain cycle
            guard let self = self else { return }
            self.data = "Loaded"
        }
    }
}

• Изменяемость: Non-escaping closure может захватывать и изменять мутабельные переменные (var) из окружающего контекста без дополнительных требований. Для escaping closure такие переменные должны быть объявлены как mutating если они находятся в структуре (struct), или требуют особого внимания из-за возможных проблем с потокобезопасностью.
• Оптимизация: Использование non-escaping closure позволяет компилятору Swift выполнять более агрессивные оптимизации памяти и исполнения, так как жизненный цикл closure точно известен. С escaping такой оптимизации нет.

Заключение

@escaping — это не просто технический атрибут, а важный концептуальный маркер в Swift, который указывает на отложенное исполнение кода и потенциальное пересечение границ времени или состояния объекта. Его правильное использование критично для работы с асинхронными API, управления жизненным циклом объектов и предотвращения утечек памяти. Понимание разницы между escaping и non-escaping closure — фундаментальный навык для разработчика iOS, напрямую влияющий на корректность, производительность и надежность приложения.