Можно ли добавить замыкания в массив?

Краткий ответ

Да, замыкания в Swift можно добавлять в массивы, так как они являются полноценными типами-значениями, соответствующими протоколам. Это фундаментальная возможность языка, которая активно используется в современной iOS-разработке.

Подробное объяснение

В Swift замыкания (closures) — это анонимные функции, которые могут захватывать значения из окружающего контекста. Поскольку замыкания являются типами-значениями (value types), они могут храниться в коллекциях, включая массивы.

Базовый пример

// Создаем массив замыканий с типом (Int) -> Int
var closures: [(Int) -> Int] = []

// Добавляем замыкания в массив
closures.append { $0 * 2 }
closures.append { $0 + 5 }
closures.append { $0 * $0 }

// Выполняем замыкания из массива
let results = closures.map { $0(3) }
print(results) // [6, 8, 9]

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

1. Единообразие типа

Все замыкания в массиве должны иметь одинаковую сигнатуру (тип параметров и возвращаемого значения). Swift обеспечивает строгую типизацию:

// ✅ Правильно - однотипные замыкания
let actions: [() -> Void] = [
    { print("Hello") },
    { print("World") }
]

// ❌ Ошибка компиляции - разные типы
// let mixedArray = [
//     { (x: Int) -> Int in return x * 2 },  // (Int) -> Int
//     { (s: String) in print(s) }           // (String) -> Void
// ]

2. Захват переменных (capture lists)

Замыкания в массиве могут захватывать значения из окружающего контекста:

var multiplier = 3
var closures: [(Int) -> Int] = []

// Замыкание захватывает текущее значение multiplier
closures.append { [multiplier] number in
    return number * multiplier
}

// Изменение multiplier не повлияет на уже добавленное замыкание
multiplier = 5
print(closures[0](2)) // 6 (а не 10), так как было захвачено значение 3

3. @escaping замыкания

Если замыкания должны пережить текущую область видимости, они должны быть помечены как @escaping:

class TaskManager {
    private var completions: [() -> Void] = []
    
    func addCompletion(_ completion: @escaping () -> Void) {
        completions.append(completion)
    }
    
    func executeAll() {
        completions.forEach { $0() }
        completions.removeAll()
    }
}

Практические применения в iOS-разработке

Обработчики событий

class Button {
    private var tapHandlers: [() -> Void] = []
    
    func addTapHandler(_ handler: @escaping () -> Void) {
        tapHandlers.append(handler)
    }
    
    func simulateTap() {
        tapHandlers.forEach { $0() }
    }
}

Цепочки преобразований

typealias StringTransform = (String) -> String

let transformers: [StringTransform] = [
    { $0.uppercased() },
    { $0.replacingOccurrences(of: " ", with: "_") },
    { "🔹 \($0) 🔹" }
]

let result = transformers.reduce("hello world") { current, transform in
    transform(current)
}
print(result) // "🔹 HELLO_WORLD 🔹"

Middleware или обработчики

typealias RequestHandler = (URLRequest) -> URLRequest

var requestModifiers: [RequestHandler] = [
    { $0.addingHeader(name: "Content-Type", value: "application/json") },
    { $0.addingHeader(name: "Authorization", value: "Bearer token") }
]

var request = URLRequest(url: URL(string: "https://api.example.com")!)
requestModifiers.forEach { modifier in
    request = modifier(request)
}

Важные предостережения

Циклические ссылки

При работе с замыканиями в массивах внутри классов нужно избегать циклов удержания:

class ViewController {
    var closures: [() -> Void] = []
    
    func setupProblematic() {
        // ❌ Создает циклическую ссылку
        closures.append {
            self.doSomething() // Сильный захват self
        }
    }
    
    func setupCorrect() {
        // ✅ Избегаем циклической ссылки
        closures.append { [weak self] in
            self?.doSomething()
        }
    }
    
    func doSomething() { /* ... */ }
}

Производительность

Хотя замыкания являются типами-значениями, они могут захватывать ссылки на объекты в куче. Каждое добавление в массив создает копию замыкания вместе с его захваченным контекстом.

Заключение

Возможность хранить замыкания в массивах — мощный инструмент Swift, который используется для:

• Создания гибких систем обработки событий
• Реализации паттернов вроде Chain of Responsibility
• Построения конвейеров обработки данных
• Управления асинхронными операциями

Ключевые аспекты для запоминания:

• Замыкания соответствуют протоколам и могут храниться в коллекциях
• Все замыкания в массиве должны иметь одинаковый тип
• Необходимо контролировать захват переменных для избежания утечек памяти
• @escaping обязательно, если замыкание будет вызвано после возврата из функции

Этот механизм активно используется в таких фреймворках как Combine и SwiftUI, где массивы замыканий часто применяются для обработки потоков событий и модификации view-иерархий.