Swift में Protocol — यह क्या है, सिंटैक्स और संभावनाएँ

Swift में Protocol क्या है?

Protocol एक अमूर्त इंटरफ़ेस है जो परिभाषित करता है कि एक प्रकार क्या करने में सक्षम होना चाहिए, लेकिन यह नहीं कि वह इसे कैसे करता है। Swift में, प्रोटोकॉल Java या Go के इंटरफ़ेस के समान है, लेकिन अतिरिक्त क्षमताओं के साथ।

एक प्रोटोकॉल आवश्यकता कर सकता है:

• इंस्टेंस और टाइप मेथड (स्टैटिक)
• प्रॉपर्टीज़ { get } या { get set } निर्दिष्टकों के साथ
• इनिशियलाइज़र
• सबस्क्रिप्ट
• Associated types (प्रोटोकॉल स्तर पर जेनेरिक)

WWDC 2015 के अनुसार, Apple ने प्रोटोकॉल-ओरिएंटेड प्रोग्रामिंग को Swift अनुप्रयोग आर्किटेक्चर के लिए एक मौलिक दृष्टिकोण के रूप में पेश किया। OOP के विपरीत, जहाँ क्लास इनहेरिटेंस कठोर पदानुक्रम बनाती है, POP प्रोटोकॉल कंपोज़िशन प्रदान करता है। यह लचीलापन देता है: एक प्रकार कई प्रोटोकॉल का अनुपालन कर सकता है, उनकी आवश्यकताओं और कार्यान्वयन को एक्सटेंशन के माध्यम से प्राप्त करता है।

प्रोटोकॉल घोषणा का सिंटैक्स

Protocol की घोषणा कीवर्ड protocol, एक नाम और एक बॉडी से की जाती है।

protocol Drawable {
    func draw(context: CGContext)
    var boundingBox: CGRect { get }
}

एक प्रकार अपने नाम के बाद कोलन का उपयोग करके प्रोटोकॉल अपनाता है:

struct Circle: Drawable {
    let center: CGPoint
    let radius: CGFloat

    func draw(context: CGContext) {
        context.addArc(center: center, radius: radius, ...)
    }

    var boundingBox: CGRect {
        CGRect(x: center.x - radius, y: center.y - radius,
               width: radius * 2, height: radius * 2)
    }
}

एक प्रकार कई प्रोटोकॉल को अल्पविराम से अलग करके अपना सकता है: struct MyType: ProtocolA, ProtocolB। कंपाइलर जाँचता है कि प्रत्येक प्रोटोकॉल की सभी आवश्यकताएँ पूरी हुई हैं या नहीं।

प्रॉपर्टी और मेथड आवश्यकताएँ

प्रॉपर्टी आवश्यकताएँ कीवर्ड var और एक्सेस निर्दिष्टकों { get } या { get set } के साथ घोषित की जाती हैं।

protocol UserProtocol {
    var name: String { get }
    var age: Int { get set }
    static var maxAge: Int { get }
    mutating func updateName(_ newName: String)
}

प्रोटोकॉल में कीवर्ड mutating इंगित करता है कि मेथड self को संशोधित कर सकता है। स्ट्रक्चर को ऐसी मेथड को mutating के रूप में लागू करना चाहिए, जबकि क्लास इसे छोड़ सकते हैं। मेथड आवश्यकताएँ पूर्ण हस्ताक्षर के साथ घोषित की जाती हैं, जिसमें पैरामीटर लेबल शामिल हैं।

प्रोटोकॉल इनहेरिटेंस

Protocol किसी अन्य प्रोटोकॉल को इनहेरिट कर सकता है, नई आवश्यकताएँ जोड़ सकता है। यह कठोर क्लास युग्मन के बिना अनुबंधों का पदानुक्रम बनाता है।

protocol Vehicle {
    var speed: Double { get set }
    func move()
}

protocol Flyable: Vehicle {
    var altitude: Double { get set }
    func takeOff()
}

Flyable अपनाने वाले प्रकार को दोनों प्रोटोकॉल — Vehicle और Flyable — की आवश्यकताओं को पूरा करना चाहिए। Swift प्रोटोकॉल की बहु-इनहेरिटेंस का समर्थन करता है: protocol A: B, C।

Protocol Composition

Protocol Composition एक तंत्र है जो यह निर्दिष्ट करने की अनुमति देता है कि एक प्रकार एक साथ कई प्रोटोकॉल का अनुपालन करना चाहिए, बिना कोई नया संयुक्त प्रोटोकॉल बनाए।

func render(_ item: Drawable & Animatable) {
    item.draw(context: ...)
    item.animate(duration: 0.3)
}

कंपोज़ीशन (&) फंक्शन पैरामीटर, वेरिएबल और जेनेरिक बाधाओं में काम करता है। कंपाइलर जाँचता है कि पास किया गया प्रकार एक साथ सभी प्रोटोकॉल को संतुष्ट करता है। SwiftUI में कंपोज़ीशन का व्यापक रूप से उपयोग किया जाता है: some View कंपोज़ीशन के साथ एक जेनेरिक है।

Protocol Composition इनहेरिटेंस पदानुक्रम बनाने से बेहतर है: protocol A: B, C के बजाय सीधे B & C अपनाया जा सकता है। यह लचीलापन देता है और युग्मन को कम करता है। कंपोज़ीशन विशेष रूप से फंक्शन पैरामीटर और जेनेरिक बाधाओं में उपयोगी है जहाँ एक मध्यवर्ती प्रोटोकॉल बनाए बिना आवश्यकताओं को अस्थायी रूप से संयोजित करने की आवश्यकता होती है। यह कोड में सहायक प्रकारों की संख्या को कम करता है।

प्रोटोकॉल एक प्रकार के रूप में

Protocol का उपयोग चर, फंक्शन पैरामीटर या संग्रह तत्व के प्रकार के रूप में किया जा सकता है। इसे एक्ज़िस्टेंशियल टाइप कहा जाता है।

var drawableItem: Drawable
let items: [Drawable] = [Circle(...), Rectangle(...)]

func process(drawables: [any Drawable]) {
    for item in drawables {
        item.draw(context: ...)
    }
}

कीवर्ड any (Swift 5.6+) स्पष्ट रूप से एक्ज़िस्टेंशियल को चिह्नित करता है। any के बिना, कंपाइलर चेतावनी जारी करता है। Swift some (अपारदर्शी प्रकार) का भी समर्थन करता है जो प्रोटोकॉल के पीछे ठोस प्रकार को छिपाने के लिए होता है — यह SwiftUI में एक मानक दृष्टिकोण है।

प्रोटोकॉल के साथ सामान्य गलतियाँ

प्रोटोकॉल के साथ काम करते समय, डेवलपर्स अक्सर कई बार-बार होने वाली गलतियाँ करते हैं।

• mutating भूल जाना — प्रोटोकॉल में एक मेथड mutating के रूप में चिह्नित है, लेकिन स्ट्रक्चर इसे कीवर्ड के बिना लागू करता है
• जेनेरिक के बजाय प्रोटोकॉल को प्रकार के रूप में उपयोग करना — जहाँ ठोस प्रकार की आवश्यकता है वहाँ <T: Drawable> के बजाय Drawable का उपयोग करना
• गोलाकार प्रोटोकॉल संदर्भ — एक प्रोटोकॉल जो उचित समाधान के बिना associated type के माध्यम से स्वयं को संदर्भित करता है
• केवल-क्लास प्रोटोकॉल — आवश्यकता के बिना AnyObject का उपयोग करना, जो स्ट्रक्चर और एनम को बाहर करता है