Протоколы в Swift: как объявить необязательные методы (полный разбор)

Протоколы в Swift: как объявить необязательные методы (полное руководство)

Вы когда-нибудь писали протокол в Swift и хотели сделать какой-то метод необязательным? Чтобы класс, который подписывается на протокол, мог не реализовывать этот метод, и компилятор не ругался? Если да — вы не одиноки. Этот вопрос из Stack Overflow собрал тысячи просмотров, и сегодня мы раз и навсегда разберёмся, как работает optional methods в Swift protocol.

Но есть нюанс: Swift — язык строгой типизации, и «чистых» необязательных методов в нём нет. Зато есть несколько элегантных обходных путей. Мы рассмотрим каждый из них, с примерами кода, чтобы вы могли выбрать подходящий для своего проекта.

Почему Swift не любит Optional Methods?

В Objective-C протоколы могли помечать методы как @optional, и всё работало. Swift же изначально создавался с прицелом на безопасность. Если протокол объявляет метод — значит, любой класс, подписанный на него, обязан его реализовать. Иначе — ошибка компиляции. Это круто, потому что вы не забудете реализовать важный метод, и код становится предсказуемым.

Но в реальной жизни часто бывает нужно: «Реализуй метод, если хочешь, а нет — используй поведение по умолчанию». Как быть? Есть три основных способа.

Способ 1: @objc и optional (классика, но с оговорками)

Самый старый и простой способ — использовать атрибут @objc. Он переносит протокол в мир Objective-C runtime, где необязательные методы существуют «из коробки».

import Foundation

@objc protocol DataSource {
    @objc optional func fetchData() -> [String]
    func mandatoryMethod()
}

class MyViewController: UIViewController, DataSource {
    func mandatoryMethod() {
        print("Обязательный метод реализован")
    }
    // fetchData() можно не реализовывать
}

// Использование:
let vc = MyViewController()
vc.fetchData?() // Безопасный вызов — ничего не произойдёт
vc.mandatoryMethod()

Плюсы: простота, понятный синтаксис, работает с делегатами.

Минусы:

• Протокол может использоваться ТОЛЬКО с классами (не структуры, не перечисления).
• Весь протокол должен быть помечен @objc.
• Вы теряете часть Swift-специфичных возможностей (associated types, where clauses).

Этот вариант идеален, если вы пишете под iOS/macOS и работаете с UIKit (например, делегаты UITableView). Но для чистого Swift-кода лучше использовать другие подходы.

Способ 2: Расширения протокола с реализацией по умолчанию (рекомендуемый)

Это самый Swift-way способ. Вы объявляете протокол с обязательными методами, а затем в расширении даёте реализацию «по умолчанию» для тех методов, которые хотите сделать необязательными.

protocol Configurable {
    func configureUI()
    func setupBindings() // хотим сделать необязательным
}

extension Configurable {
    func setupBindings() {
        // Пустая реализация по умолчанию
        print("Биндинги не настроены (используется стандартная реализация)")
    }
}

class MyView: Configurable {
    func configureUI() {
        print("UI настроен")
    }
    // setupBindings() можно не писать — будет использована реализация из расширения
}

class AdvancedView: Configurable {
    func configureUI() {
        print("Продвинутый UI")
    }
    func setupBindings() {
        print("Свои биндинги")
    }
}

let view = MyView()
view.setupBindings() // Выведет: "Биндинги не настроены (используется стандартная реализация)"

let advanced = AdvancedView()
advanced.setupBindings() // Выведет: "Свои биндинги"

Почему это круто?

• Работает с классами, структурами и перечислениями.
• Полностью Swift-нативный, без objc.
• Вы можете переопределить метод, а можете оставить поведение по умолчанию.

Единственный минус: вы не можете проверить, реализовал ли конкретный тип этот метод или использует дефолтную версию. Но на практике это редко нужно.

Способ 3: Возвращаемый тип Optional (хитрость с дженериками)

Иногда вам нужно, чтобы метод мог «отсутствовать» в принципе. Например, делегат может вернуть nil, если не хочет обрабатывать событие. Здесь на помощь приходят опциональные возвращаемые значения.

protocol EventHandler {
    func handleEvent(_ event: String) -> Bool? // nil = не обрабатываю
}

class MainHandler: EventHandler {
    func handleEvent(_ event: String) -> Bool? {
        if event == "login" {
            return true
        }
        return nil // пропускаем другие события
    }
}

class NullHandler: EventHandler {
    func handleEvent(_ event: String) -> Bool? {
        return nil // вообще ничего не обрабатываем
    }
}

// Использование:
let handler = MainHandler()
if let result = handler.handleEvent("logout") {
    print("Событие обработано: \(result)")
} else {
    print("Событие проигнорировано")
}

Это не «настоящие» необязательные методы, но часто они решают ту же задачу: дают возможность не реагировать на вызов.

Сравнение подходов: что выбрать?

Живой пример: Делегат для кастомного UI

Давайте соберём всё вместе. Представьте, что вы пишете кастомную кнопку с делегатом. Вы хотите, чтобы didTap был обязательным, а didLongPress — опциональным.

protocol CustomButtonDelegate: AnyObject {
    func didTap(_ button: CustomButton)
    func didLongPress(_ button: CustomButton) // делаем опциональным
}

extension CustomButtonDelegate {
    func didLongPress(_ button: CustomButton) {
        // Ничего не делаем по умолчанию
    }
}

class CustomButton {
    weak var delegate: CustomButtonDelegate?
    
    func simulateTap() {
        delegate?.didTap(self)
    }
    
    func simulateLongPress() {
        delegate?.didLongPress(self) // безопасно, даже если не реализовано
    }
}

class ViewController: UIViewController, CustomButtonDelegate {
    let button = CustomButton()