Ce încalcă funcția opțională din protocol?

Adăugarea cerințelor la protocol după ce acesta a fost utilizat de alte module sau biblioteci. Dacă protocolul a fost deja acceptat și implementat, adăugarea de metode sau proprietăți obișnuite (ne-opționale) va duce la erori de compilare în toate locurile unde este utilizat, până când aceste noi cerințe sunt îndeplinite.

Cerințele opționale permit extinderea protocolurilor fără a "strica" implementările existente. Clasele sau structurile pot implementa doar o parte din metodele opționale. Acest lucru este util atunci când se lucrează cu delegați sau când se adaugă funcții noi într-un API deja stabilit.

Exemplu de cerință opțională într-un protocol în Objective-C (deoarece Swift nu suportă @optional fără @objc):

// În Swift, @optional se folosește cu @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 {
            // Apelăm metoda opțională cu verificare
            delegate?.optionalMethod1?()

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

În Swift, protocoalele pure (fără @objc) nu suportă @optional. Pentru a avea cerințe opționale, protocolul trebuie marcat ca @objc. Implementările acestor protocoale pot folosi extensii pentru a adăuga implementări implicite ale metodelor opționale, ceea ce reprezintă o abordare mai modernă în Swift.

Exemplu de comportament opțional prin extensii de protocoale în Swift:

// Abordare mai Swift-ificată: extensii de protocoale cu implementare implicită
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Oferim implementări implicite pentru metodele "opționale"
extension MyProtocol {
    func optionalMethod1() {
        // Implementare implicită goală sau comportament standard
        print("Implementare implicită pentru metoda opțională 1")
    }

    func optionalMethod2(value: Int) {
        // Implementare implicită goală
        print("Implementare implicită pentru metoda opțională 2 cu valoarea: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Apelăm metodele fără verificare de nil pentru metodele opționale, deoarece
            // fie sunt implementate în clasă/struct, fie se folosește implementarea din extensie
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Metoda obligatorie implementată")
        return true
    }

    // optionalMethod1() și optionalMethod2(value:) nu sunt obligatorii de implementat,
    // se va folosi implementarea implicită din extensie.
    // Dar se pot suprascrie dacă se dorește un comportament diferit:
    // func optionalMethod1() {
    //     print("Implementare personalizată pentru metoda opțională 1")
    // }
}

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

Astfel, încercarea de a adăuga o funcție opțională într-un protocol deja utilizat în bazele de cod încalcă compatibilitatea retroactivă. Utilizarea cerințelor opționale (prin @objc sau, preferabil, prin extensii de protocoale) previne această problemă.