Почему используется Capture List, а не weak self?

Зачем нужен Capture List вместо просто weak self?

Capture List — это специальный синтаксис в Swift, который позволяет явно контролировать, как значения захватываются внутри замыкания (closure). Использование просто weak self внутри замыкания невозможно без Capture List, потому что синтаксис weak self является частью именно Capture List. Поэтому вопрос можно переформулировать: почему мы используем Capture List с указанием weak self, а не просто полагаемся на автоматическое захват значений?

Основная проблема: циклические ссылки и утечки памяти

Swift использует ARC (Automatic Reference Counting) для управления памятью. Однако при захвате сильных ссылок (strong) внутри замыкания могут возникать циклические зависимости, особенно когда замыкание является свойством объекта и захватывает сам этот объект (self). Пример:

class DataManager {
    var data: [String] = []
    var onUpdate: (() -> Void)?
    
    func fetchData() {
        // Замыкание захватывает self сильной ссылкой
        onUpdate = {
            self.processData() // Потенциальная циклическая ссылка!
        }
    }
    
    func processData() {
        print("Processing data")
    }
}

Если onUpdate хранится как свойство в DataManager, а внутри захватывает self, образуется цикл: DataManager держит замыкание, а замыкание держит DataManager. Это приводит к утечке памяти — объекты никогда не освобождаются.

Решение через Capture List

Capture List позволяет явно указать, как захватывать переменные:

func fetchData() {
    onUpdate = { [weak self] in
        self?.processData() // self теперь weak, ссылка безопасна
    }
}

Почему именно Capture List, а не другой механизм?

1. Явность и контроль: Capture List делает захват значений явным. Вы видите, какие переменные захватываются и как (weak, unowned, strong). Это повышает читаемость и предотвращает случайные ошибки.
2. Разные типы захвата: Не всегда нужен weak. Capture List позволяет выбрать подходящий тип:
   • weak: безопасная нулевая ссылка, когда объект может быть освобожден.
   • unowned: ненулевая ссылка, когда объект гарантированно существует во время жизни замыкания (но рискованно, если гарантия нарушается).
   • strong: явное указание сильной ссылки, если это необходимо (например, для коротких замыканий, которые не хранятся долго).
3. Захват нескольких значений: Capture List позволяет контролировать захват не только self, но и других переменных:

onUpdate = { [weak self, unowned database = self.db] in
    self?.processData(from: database)
}

Когда использовать weak self через Capture List?

Основные случаи:

• Замыкание является свойством класса и захватывает сам класс.
• Замыкание выполняется асинхронно (например, в DispatchQueue, сетевом запросе), и объект может быть освобожден до вызова замыкания.
• Замыкание хранится долго (например, в наблюдателях, колбэках).

Сравнение с автоматическим захватом

Swift автоматически захватывает сильные ссылки на все переменные, используемые внутри замыкания. Это удобно для простых случаев, но опасно в сложных. Capture List переопределяет это поведение, давая разработчику контроль.

Пример опасности автоматического захвата:

class ViewController {
    var completion: (() -> Void)?
    
    func setupCompletion() {
        let resource = Resource()
        completion = {
            resource.use() // resource захвачен strongly, даже если он локальный!
            // resource не освободится, пока completion существует.
        }
    }
}

Здесь Capture List мог бы помочь:

completion = { [weak resource] in
    resource?.use()
}

Вывод

Capture List — это не альтернатива weak self, а синтаксический инструмент для реализации weak self и других стратегий захвата. Его использование необходимо для:

• Предотвращения циклических ссылок.
• Явного управления памятью в замыканиях.
• Обеспечения безопасности и читаемости кода.

Простое указание weak self внутри замыкания невозможно без Capture List — это его часть. Поэтому мы всегда используем Capture List, когда нужно контролировать захват, вместо того чтобы полагаться на автоматическое поведение Swift, которое часто приводит к утечкам памяти.