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

Запрет не позволяет замыканию получить ссылку на частично инициализированный объект. До завершения инициализации все stored-свойства должны иметь корректные значения, иначе escaping-замыкание может сохраниться где-то ещё и обратиться к объекту в недопустимом состоянии.

ARC управляет временем жизни уже созданных объектов, но не делает безопасным использование объекта до завершения его инициализации. Поэтому захват self разрешается только после того, как экземпляр прошёл необходимые этапы инициализации.

Исторический контекст

В языках с ручным управлением памятью разработчик мог передать наружу указатель на объект прямо из инициализатора. Это создавало риск обращения к не полностью настроенному объекту, особенно если callback вызывался немедленно или сохранялся другим объектом.

Swift объединил автоматическое управление памятью с проверкой definite initialization. Компилятор заранее контролирует, что stored-свойства инициализированы до использования self, вместо того чтобы оставлять такую проверку на ответственность разработчика.

Постановка проблемы

Escaping-замыкание может пережить текущий вызов инициализатора: его можно сохранить в свойстве, передать менеджеру событий или поставить в очередь. Если такое замыкание захватит self слишком рано, экземпляр станет доступен коду до завершения настройки его состояния.

Последствиями могут быть чтение неинициализированного свойства, вызов метода на неполностью созданном объекте или утечка ссылки наружу во время неуспешной инициализации. Слабый захват не устраняет саму проблему: даже для формирования [weak self] нужно получить ссылку на self, а до завершения инициализации это запрещено.

Подробное решение

Сначала инициализатор должен присвоить значения всем stored-свойствам текущего класса. Только после этого self можно захватывать замыканием, передавать наружу или использовать для вызова методов.

final class Screen {
    let title: String
    var handler: (() -> Void)?

    init(title: String) {
        self.title = title
        self.handler = { [weak self] in
            guard let self else { return }
            print(self.title)
        }
    }
}

В примере title инициализирован до создания замыкания. Свойство handler имеет optional-тип и также получает значение до того, как инициализатор завершится; после этого захват self допустим.

Если callback хранится внутри самого объекта, сильный захват self обычно создаёт цикл: объект владеет замыканием, а замыкание владеет объектом. Поэтому после завершения инициализации часто выбирают [weak self], но это уже отдельное решение о графе владения, а не способ обойти правило инициализации.

Для класса-наследника действует дополнительный порядок: его собственные stored-свойства должны быть инициализированы до вызова инициализатора суперкласса, а использование self в полной мере допустимо после завершения необходимых этапов инициализации суперкласса. Это предотвращает публикацию объекта, у которого не завершена настройка всей цепочки наследования.

Ситуация из практики

Экран при инициализации регистрирует callback в менеджере событий. Вариант с захватом self до присвоения всех свойств компилятор отклонит. Перенос регистрации после инициализации состояния устраняет ошибку, но сильный захват может оставить экран в памяти после закрытия.

Вариант с сильным захватом проще по времени жизни: callback всегда видит экран, пока сам зарегистрирован. Его минус — возможный retain cycle между экраном, менеджером или свойством callback и замыканием.

Вариант со слабым захватом не удерживает экран и предотвращает цикл. Его компромисс — callback может ничего не сделать, если экран уже уничтожен; для обработчика события это обычно ожидаемое поведение.

Практическое решение: завершить инициализацию всех свойств, затем зарегистрировать callback и использовать [weak self], если регистрационный объект живёт дольше экрана. В результате компилятор гарантирует корректную инициализацию, а ARC сможет уничтожить экран после исчезновения остальных сильных владельцев.

Что кандидаты часто упускают

1. Достаточно ли заменить сильный захват на weak, чтобы захватить self до завершения инициализации?

Нет. [weak self] всё равно требует обратиться к self в момент создания замыкания. Слабость ссылки влияет на последующее владение объектом, но не отменяет правила definite initialization.

2. Можно ли передать self наружу сразу после инициализации свойств текущего класса, но до вызова super.init?

Нет, для подкласса инициализация ещё не завершена: часть состояния суперкласса пока не настроена. Сначала подкласс должен инициализировать свои свойства и корректно вызвать super.init; только затем объект можно безопасно использовать как полностью инициализированный экземпляр.

3. Почему компилятор особенно строго относится к escaping-замыканиям?

Non-escaping-замыкание ограничено текущим вызовом и не может сохраниться после его завершения, хотя использование self до полной инициализации всё равно ограничивается правилами инициализации. Escaping-замыкание может пережить инициализатор, поэтому ранний захват превращается в публикацию потенциально неполного объекта за пределы текущего кода.