Для чего нужен non-Escaping?

Основное назначение non-escaping closure

non-escaping closure — это замыкание, которое гарантированно выполняется внутри тела функции, до её завершения. Это поведение по умолчанию для замыканий в Swift, начиная с версии 3.0.

Ключевая цель non-escaping

Главная цель — гарантировать отсутствие retain cycles и обеспечить безопасность памяти. Компилятор может оптимизировать такие замыкания, поскольку знает, что они не будут вызваны после возврата из функции.

Основные случаи использования:

1. Синхронные операции

   func processItems(_ items: [Int], using transform: (Int) -> Int) -> [Int] {
       // Замыкание выполняется немедленно внутри функции
       return items.map(transform)
   }
   

2. Алгоритмы высшего порядка

   let numbers = [1, 2, 3, 4, 5]
   let doubled = numbers.filter { $0 % 2 == 0 }
                        .map { $0 * 2 } // Оба замыкания non-escaping
   

3. Асинхронные операции с гарантией завершения

   func performWithAnimation(_ duration: TimeInterval, 
                            animations: () -> Void,
                            completion: () -> Void) {
       UIView.animate(withDuration: duration, 
                      animations: animations,
                      completion: { _ in completion() })
   }
   

Технические преимущества

1. Безопасность памяти

Поскольку замыкание не покидает область видимости функции, нет необходимости использовать [weak self] или [unowned self]:

class DataProcessor {
    func process(data: [String], handler: (String) -> Bool) {
        // Не нужно weak self - замыкание не убежит
        data.forEach { item in
            if handler(item) {
                print("Processed: \(item)")
            }
        }
    }
}

2. Оптимизация производительности

Компилятор может выполнить оптимизации:

• Инлайнинг замыкания
• Отказ от выделения памяти в куче (heap allocation)
• Устранение накладных расходов на ARC

3. Упрощение семантики захвата

В non-escaping closure захват переменных происходит более предсказуемо:

func calculateTotal(_ prices: [Double], 
                   applyDiscount: (Double) -> Double) -> Double {
    var discountMultiplier = 0.9
    let adjustedPrices = prices.map { price in
        // Захватываем discountMultiplier безопасно
        applyDiscount(price) * discountMultiplier
    }
    return adjustedPrices.reduce(0, +)
}

Когда выбирать non-escaping vs escaping

Практический пример

// Non-escaping - правильный выбор для синхронной обработки
func validateInput(_ text: String, 
                  validationRule: (String) -> Bool) -> Bool {
    // Замыкание выполняется сразу и не сохраняется
    return validationRule(text)
}

// Escaping - нужен для асинхронных операций
func fetchData(completion: @escaping (Result<Data, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, _, error in
        // Замыкание будет вызвано ПОСЛЕ возврата из fetchData
        completion(.success(data!))
    }.resume()
}

Итог: non-escaping closure — это фундаментальный механизм Swift для обеспечения безопасной и эффективной работы с замыканиями в синхронных контекстах. Они позволяют писать более безопасный код, избегая случайных retain cycles, и дают компилятору возможность для агрессивных оптимизаций, что особенно важно для мобильных приложений с ограниченными ресурсами.