Что такое паттерн Делегат (Delegate) в iOS?

Тип вопроса: Паттерны Вероятность: 22% Категория: IOS Разработчик

Ответ

Паттерн Делегат — это поведенческий паттерн проектирования, который позволяет одному объекту (делегату) обрабатывать события или предоставлять данные для другого объекта. Это основной способ реализации обратной связи и разделения ответственности в Cocoa Touch.

Основные компоненты:

  1. Протокол делегата: Определяет контракт — методы, которые может (или должен) реализовать делегат.
  2. Объект-источник (Delegating Object): Имеет слабую (weak) ссылку на делегата. Он вызывает методы делегата при наступлении событий (например, пользователь выбрал ячейку таблицы).
  3. Делегат: Объект, который подписывается на протокол и реализует его методы, чтобы реагировать на события.

Пример:

// 1. Протокол делегата
protocol CustomButtonDelegate: AnyObject {
    func buttonDidTap(_ button: CustomButton)
}

// 2. Объект-источник (имеет делегата)
class CustomButton: UIButton {
    weak var delegate: CustomButtonDelegate? // Слабая ссылка для избежания циклов удержания

    @objc private func handleTap() {
        delegate?.buttonDidTap(self) // Сообщение делегату о событии
    }
}

// 3. Делегат (реагирует на события)
class ViewController: UIViewController, CustomButtonDelegate {
    let button = CustomButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        button.delegate = self // Установка делегата
    }

    // Реализация метода протокола
    func buttonDidTap(_ button: CustomButton) {
        print("Кнопка была нажата")
    }
}

Почему weak? Чтобы избежать цикла сильных ссылок (например, когда ViewController владеет button, а button держит сильную ссылку на ViewController).

Ответ 18+ 🔞

А, паттерн Делегат! Ну это ж классика, блядь, как хлеб с маслом в iOS-разработке. Стоит только открыть любой контроллер — а там уже дохуя делегатов, протоколов и прочей хуйни. Сейчас разжуем, как это работает, чтобы не было мучительно больно за свой код.

Представь себе, блядь, такую ситуацию. Есть у тебя кнопка, тупая, как пробка. Она знает только одно — её нажали. А что делать дальше — ей похуй. Её задача — крикнуть кому-то: «Эй, мудак, меня ткнули, делай что-нибудь!». Вот этот «кто-то» и есть делегат.

Из чего это говно состоит:

  1. Протокол делегата. Это как инструкция, блядь, для идиота. Чёткий список: «Слушай, если хочешь быть моим делегатом, ты обязан уметь делать ТО-ТО и ТО-ТО». Пишется на бумажке и называется protocol.

  2. Объект-источник (тот, кто делегирует). Это наша кнопка-дура. У неё есть свойство delegate, куда она может тыкнуть пальцем и сказать: «Вот этот чувак — мой начальник, ему я буду жаловаться».

  3. Сам делегат. Это тот самый «начальник», который взял эту бумажку-протокол, прочитал и сказал: «Окей, я умею всё, что тут написано». И когда кнопка орёт, он встаёт и идёт делать свою работу.

Смотри, как это выглядит в коде, ёпта:

// 1. Пишем ту самую бумажку-инструкцию (протокол)
protocol CustomButtonDelegate: AnyObject { // AnyObject — это важно, запомни!
    func buttonDidTap(_ button: CustomButton) // Единственное требование: умей обработать тап
}

// 2. Делаем нашу тупую кнопку
class CustomButton: UIButton {
    // СЛЫШЬ, ВАЖНО! Ссылка на делегата ДОЛЖНА БЫТЬ weak!
    weak var delegate: CustomButtonDelegate?

    @objc private func handleTap() {
        // А вот и момент истины. Кнопку ткнули, она смотрит: а делегат-то назначен?
        // Если назначен — орёт ему: buttonDidTap(self)!
        delegate?.buttonDidTap(self)
    }
}

// 3. Делаем умного дядю-делегата (обычно это ViewController)
class ViewController: UIViewController, CustomButtonDelegate { // Говорим: "Я подписываюсь на твою бумажку!"
    let button = CustomButton()

    override func viewDidLoad() {
        super.viewDidLoad()
        button.delegate = self // Говорим кнопке: "Слушай, сынок, твой начальник теперь — я!"
    }

    // А вот и реализация того самого метода из бумажки-протокола.
    // Когда кнопка наорёт, выполнится этот код.
    func buttonDidTap(_ button: CustomButton) {
        print("Бля, кнопку реально нажали! Делаем что-то полезное.")
    }
}

А теперь главный вопрос, на котором все спотыкаются, как обосанные: нахуя тут weak?

Представь, блядь:

  • ViewController крепко держит за жопу свою button (сильная ссылка let button).
  • Button в свойстве delegate тоже начинает крепко держать за жопу ViewController (ещё одна сильная ссылка).

Получается пиздец, ёпта — цикл сильных ссылок. Они обнимаются и никуда не отпускают друг друга. ViewController не может умереть, потому что его держит button. Button не может умереть, потому что её держит ViewController. Память течёт, приложение падает, пользователи негодуют.

weak — это как сказать: «Я тебя знаю, но за жопу не держу». Button просто знает о существовании своего делегата, но не владеет им. Когда ViewController захочет умереть (например, когда экран закроют), его отпустят все сильные ссылки, и он спокойно сдохнет. А button.delegate просто станет nil, и всё.

Вот и весь секрет, блядь. Объект-дурак делегирует работу умному объекту через протокол, а weak спасает от вечных объятий в аду утечек памяти. Красота, ёпта!

© ХакСобесов, 2026
support@hacksobesov.com