В чем разница между передачей данных через Closure и Delegate?

Разница между Closure и Delegate в Swift

В iOS разработке на Swift обе паттерны — Closure (замыкания) и Delegate (делегирование) — используются для передачи данных и обратной связи, но имеют фундаментальные различия в архитектуре, применении и степени связности компонентов.

Closure (Замыкание)

Closure — это анонимная функция, которая может захватывать контекст и передаваться как параметр или храниться в свойстве. Передача данных через замыкание обычно происходит в форме callback (обратного вызова).

class DataLoader {
    func loadData(completion: @escaping (Result<Data, Error>) -> Void) {
        // Асинхронная операция
        DispatchQueue.global().async {
            let data = Data()
            completion(.success(data))
        }
    }
}

// Использование
let loader = DataLoader()
loader.loadData { result in
    switch result {
    case .success(let data): print("Data received: \(data)")
    case .failure(let error): print("Error: \(error)")
    }
}

Ключевые характеристики Closure:

• Одноразовость: Часто используется для единичных обратных вызовов (например, завершение сетевого запроса).
• Локальный контекст: Логика обработки определяется непосредственно в месте вызова, что упрощает чтение кода для простых операций.
• Слабая связь: Не требует создания отдельного протокола или класса-делегата.
• Захват контекста: Может захватывать и хранить ссылки на внешние переменные (self, свойства), что требует внимания к памяти (циклам сильных ссылок).

Delegate (Делегирование)

Delegate — это паттерн, где один объект (делегат) принимает на себя ответственность за выполнение определенных задач или обработку событий другого объекта. В Swift это реализуется через протоколы.

protocol DataLoaderDelegate: AnyObject {
    func dataLoader(_ loader: DataLoader, didLoad data: Data)
    func dataLoader(_ loader: DataLoader, didFailWith error: Error)
}

class DataLoader {
    weak var delegate: DataLoaderDelegate?
    
    func loadData() {
        DispatchQueue.global().async {
            let data = Data()
            self.delegate?.dataLoader(self, didLoad: data)
        }
    }
}

// Класс, реализующий делегирование
class ViewController: UIViewController, DataLoaderDelegate {
    let loader = DataLoader()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        loader.delegate = self
        loader.loadData()
    }
    
    func dataLoader(_ loader: DataLoader, didLoad data: Data) {
        print("Delegate received data: \(data)")
    }
    
    func dataLoader(_ loader: DataLoader, didFailWith error: Error) {
        print("Delegate received error: \(error)")
    }
}

Ключевые характеристики Delegate:

• Многократное взаимодействие: Предназначен для долгосрочного отношения между объектами, с множеством событий.
• Строгая типизация: Протокол четко определяет контракт — какие методы должны быть реализованы.
• Сепарация логики: Отделяет логику обработки событий (в делегате) от логики генератора событий.
• Слабые ссылки: Делегат обычно объявляется как weak var, чтобы избежать циклов сильных ссылок.
• Шаблонность: Часто используется в UIKit (UITableViewDelegate, UITextFieldDelegate).

Сравнение и выбор паттерна

Когда использовать Closure:

• Для асинхронных операций с одним результатом (сетевые запросы, обработка изображений).
• В функциях высшего порядка (map, filter) и современных Swift API.
• Когда логика обработки проста и локальна.

Когда использовать Delegate:

• Для компонентов с множеством событий (таблица, текстовое поле).
• Когда нужна четкая сепарация обязанностей между модулями.
• В долгосрочных отношениях между объектами (например, контроллер и сервис).
• Для совместимости с legacy UIKit кодом.

Заключение

Выбор между Closure и Delegate зависит от контекста задачи. Closure предлагают современный, компактный способ для одноразовых callback-ов, особенно в асинхронном коде. Delegate предоставляет структурированный, многометодный интерфейс для сложных взаимодействий, характерных для классической iOS архитектуры. В современных приложениях часто наблюдается гибридный подход: использование Closure для завершения операций и Delegate для управления жизненным циклом и множеством событий компонентов UI.