Как нарушава опционалната функция в протокола?

Добавяне на изисквания към протокол след като той вече се използва от други модули или библиотеки. Ако протоколът вече е приет и реализиран, добавянето на обикновени (неопционални) методи или свойства ще доведе до грешки при компилацията навсякъде, където се използва протоколът, докато тези нови изисквания не бъдат изпълнени.

Опционалните изисквания позволяват разширяване на протоколите, без да "развалят" съществуващите реализации. Класовете или структурите могат да реализират само част от опционалните методи. Това е полезно при работа с делегати или при добавяне на нови функции към вече установен API.

Пример за опционално изискване в протокол в Objective-C (тъй като Swift не поддържа @optional без @objc):

// В Swift `@optional` се използва с `@objc protocol`
import Foundation

@objc protocol MyDelegate {
    func requiredMethod() -> Bool

    @optional func optionalMethod1()
    @optional func optionalMethod2(value: Int)
}

class MyClass {
    weak var delegate: MyDelegate?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Извикваме опционалния метод с проверка
            delegate?.optionalMethod1?()

            if let delegate = delegate {
                if delegate.responds(to: #selector(delegate.optionalMethod2(value:))) {
                    delegate.optionalMethod2?(value: 10)
                }
            }
        }
    }
}

В Swift, чистите протоколи (без @objc) не поддържат @optional. За да имат опционални изисквания, протоколът трябва да бъде маркиран като @objc. Реализациите на такива протоколи могат да използват разширения за добавяне на реализации по подразбиране на опционалните методи, което е по-модерен подход в Swift.

Пример за опционално поведение чрез разширения на протоколи в Swift:

// По-модерен подход: разширения на протоколи с реализация по подразбиране
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Предоставяме реализации по подразбиране за "опционалните" методи
extension MyProtocol {
    func optionalMethod1() {
        // Празна реализация по подразбиране или стандартно поведение
        print("Реализация по подразбиране за optionalMethod1")
    }

    func optionalMethod2(value: Int) {
        // Празна реализация по подразбиране
        print("Реализация по подразбиране за optionalMethod2 с стойност: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Извикваме методите без проверка за nil, тъй като
            // или са реализирани в класа/структурата, или се използва
            // реализацията от разширението
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Изпълнена е задължителната метода")
        return true
    }

    // optionalMethod1() и optionalMethod2(value:) не е задължително да се реализират,
    // ще се използва реализацията по подразбиране от разширението.
    // Но могат да бъдат преопределени, ако е необходимо друго поведение:
    // func optionalMethod1() {
    //     print("Персонализирана реализация на optionalMethod1")
    // }
}

let customDelegate = MyCustomDelegate()
let myClassSwift = MyClassSwift()
myClassSwift.delegate = customDelegate
myClassSwift.doSomething()

По този начин, опитът да се добави нова задължителна функция към вече съществуващ протокол, който се използва в кодовата база, нарушава обратната съвместимост.