რა არღვევს პროტოკოლში არჩევით ფუნქციას?

პროტოკოლში მოთხოვნების დამატება, როდესაც სხვა მოდულები ან ბიბლიოთეკები უკვე იყენებენ მას. თუ პროტოკოლი უკვე მიღებულია და განხორციელებულია, ჩვეულებრივი (არასავალდებულო) მეთოდების ან თვისებების დამატება გამოიწვევს კოდში შეცდომებს ყველა ადგილას, სადაც პროტოკოლი გამოიყენება, სანამ ეს ახალი მოთხოვნები შესრულდება:

სავალდებულო მოთხოვნები საშუალებას აძლევს გაფართოვდეს პროტოკოლები, არ დაარღვიოს არსებული რეალიზაცია. კლასები ან სტრუქტურები შეიძლება მხოლოდ ნაწილობრივ განახორციელონ სავალდებულო მეთოდები. ეს სასარგებლოა დელეგატორებთან მუშაობისას ან როდესაც უკვე ჩამოყალიბებული API-ში ემატება ახალი ფუნქციები:

მაგალითად, Objective-C-ში სავალდებულო მოთხოვნის მაგალითი (რადგან Swift-ი არ უჭერს მხარს @optional-ს @objc-ის გარეშე):

// Swift-ში @optional გამოიყენება @objc პროტოკოლთან
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-ში:

// უფრო Swift-იანი მიდგომა: პროტოკოლების გაფართოებები დეფოლტ რეალიზაციით
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// დეფოლტ რეალიზაციები სავალდებულო მეთოდებისთვის
extension MyProtocol {
    func optionalMethod1() {
        // დეფოლტ რეალიზაცია ან სტანდარტული ქცევა
        print("Optional method 1 default implementation")
    }

    func optionalMethod2(value: Int) {
        // დეფოლტ რეალიზაცია
        print("Optional method 2 default implementation with value: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // მეთოდების გამოძახება, რომლებიც ან რეალიზებულია, ან გაფართოებიდან მოდის
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Required method implemented")
        return true
    }

    // optionalMethod1() და optionalMethod2(value:) არ არის აუცილებელი რეალიზება,
    // გამოიყენება გაფართოებიდან დეფოლტ რეალიზაცია.
    // მაგრამ შესაძლებელია მათი გადაფარვა, თუ სხვა ქცევა გსურთ:
    // func optionalMethod1() {
    //     print("Custom implementation of optional method 1")
    // }
}

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

ამრიგად, სავალდებულო ფუნქციის დამატება პროტოკოლში, რომელიც უკვე გამოიყენება კოდში, არღვევს უკუგანათვლას. სავალდებულო მოთხოვნები (@objc ან გაფართოებების გამოყენებით) თავიდან აცილებს ამ პრობლემას.