Mi sérti meg az opcionális funkciót a protokollban?

A követelmények hozzáadása a protokollhoz, miután más modulok vagy könyvtárak már használják. Ha a protokoll már elfogadott és megvalósított, akkor a szokásos (nem opcionális) metódusok vagy tulajdonságok hozzáadása fordítási hibákat eredményez minden olyan helyen, ahol a protokollt használják, amíg ezek az új követelmények nem teljesülnek.

Az opcionális követelmények lehetővé teszik a protokollok bővítését anélkül, hogy "megráznák" a meglévő megvalósításokat. Osztályok vagy struktúrák csak egy részét valósíthatják meg az opcionális metódusoknak. Ez hasznos delegáltakkal való munkában vagy amikor új funkciókat adunk hozzá már meglévő API-hoz.

Példa opcionális követelményre Objective-C protokollban (mivel Swift nem támogatja az @optional-t @objc nélkül):

// Swiftben az `@optional` az `@objc protocol`-lal használható
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 {
            // Opcionális metódus hívása ellenőrzéssel
            delegate?.optionalMethod1?()

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

Swiftben a tiszta protokollok (@objc nélkül) nem támogatják az @optional-t. Az ilyen protokollok opcionális követelményekhez @objc-nak kell lenniük. Az ilyen protokollok megvalósításai kiterjesztéseket használhatnak az alapértelmezett implementációk hozzáadására, ami modernebb megközelítés Swiftben.

Példa opcionális viselkedésre protokoll kiterjesztéseken keresztül Swiftben:

// Modernebb Swift-hez: protokoll kiterjesztések alapértelmezett implementációkkal
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Alapértelmezett implementációk biztosítása az "opcionális" metódusokhoz
extension MyProtocol {
    func optionalMethod1() {
        // Alapértelmezett üres implementáció vagy standard viselkedés
        print("Alapértelmezett implementáció az opcionális 1-es metódushoz")
    }

    func optionalMethod2(value: Int) {
        // Alapértelmezett üres implementáció
        print("Alapértelmezett implementáció a 2-es metódushoz értékkel: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Metódusok hívása nil ellenőrzés nélkül, mivel
            // vagy a class/struct implementálja, vagy az extensionből származik
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Szükséges metódus implementálva")
        return true
    }

    // Az optionalMethod1() és optionalMethod2(value:) nem kötelező implementálni,
    // az extensionből származó alapértelmezett viselkedést fogják használni.
    // De felülírhatók, ha más viselkedést szeretnénk:
    // func optionalMethod1() {
    //     print("Egyedi implementáció az opcionális 1-es metódushoz")
    // }
}

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

Így az opcionális funkció hozzáadása egy már használt protokollhoz megsérti a visszamenőleges kompatibilitást.