Protokolda ixtiyoriy funktsiyani nima buzadi?

Boshqa modullar yoki kutubxonalar uni ishlatishni boshlaganidan keyin protokolga talablarni qo'shish. Agar protokol allaqachon qabul qilingan va amalga oshirilgan bo'lsa, oddiy (majburiy bo'lmagan) metodlar yoki xususiyatlarni qo'shish, bu protokol ishlatiladigan barcha joylarda kompilyatsiya xatolariga olib keladi, bu yangi talablar bajarilmaguncha.

Majburiy bo'lmagan talablar protokollarni mavjud amalga oshirishlarni "yoki" buzmasdan kengaytirishga imkon beradi. Sinflar yoki tuzilmalar faqat majburiy bo'lmagan metodlarning bir qismini amalga oshirishi mumkin. Bu delegatlar bilan ishlashda yoki allaqachon barpo etilgan API ga yangi funksiyalar qo'shishda foydalidir.

Objective-C protokolida majburiy bo'lmagan talab misoli (Swift @optional ni @objcsiz qo'llab-quvvatlamaydi):

// Swiftda, `@optional` `@objc protocol` bilan ishlatiladi
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 {
            // Opsiyonel metodni chaqirish va tekshirish
            delegate?.optionalMethod1?()

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

Swiftda, toza protokollar (@objcsiz) @optional ni qo'llab-quvvatlamaydi. Majburiy bo'lmagan talablar uchun, protokol @objc bilan belgilanishi kerak. Bunday protokolning amalga oshirilmalari, standart majburiy bo'lmagan metodlarni qo'shish uchun kengaytmalar yordamida foydalanishi mumkin, bu Swiftda yanada zamonaviy yondashuvdir.

Swiftda protokol kengaytmalari orqali majburiy bo'lmagan xatti-harakat misoli:

// Yanada Swift-yo'naltirilgan yondashuv: standart amalga oshirishlar bilan protokol kengaytmalari
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Standart amalga oshirishlarni taqdim etamiz
extension MyProtocol {
    func optionalMethod1() {
        // Standart bo'sh amalga oshirish yoki standart xatti-harakat
        print("Standart majburiy bo'lmagan metod 1")
    }

    func optionalMethod2(value: Int) {
        // Standart bo'sh amalga oshirish
        print("Standart majburiy bo'lmagan metod 2, qiymat: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Nil tekshirmasdan metodlarni chaqiramiz, chunki
            // ular yoki sinf/strukturda amalga oshirilgan yoki
            // kengaytma yordamida taqdim etilgan
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Majburiy metod amalga oshirildi")
        return true
    }

    // optionalMethod1() va optionalMethod2(value:) majburiy emas,
    // kengaytma yordamida taqdim etilgan amalga oshirish ishlatiladi.
    // Ammo ular boshqa xatti-harakat uchun qayta yozilishi mumkin:
    // func optionalMethod1() {
    //     print("Majburiy bo'lmagan metodning maxsus amalga oshirilishi")
    // }
}

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

Shunday qilib, protokolga majburiy bo'lmagan funksiyani qo'shish, mavjud protokolga yangi majburiy talabni qo'shishga urinishda orqaga mos kelmaslikka olib keladi. @objc yoki, afzalroq, protokol kengaytmalari yordamida majburiy bo'lmagan talablar bu muammoni oldini oladi.