Swift में Generics: कोड उदाहरणों के साथ पूर्ण गाइड

Swift में Generics: क्यों आवश्यक हैं और व्यावहारिक रूप से कैसे उपयोग करें

Generics (सामान्यीकृत प्रोग्रामिंग) — Swift भाषा की सबसे शक्तिशाली और मौलिक क्षमताओं में से एक है। ये आपको लचीला, टाइप-सुरक्षित और पुन: प्रयोज्य कोड लिखने की अनुमति देते हैं, जिससे दोहराव से बचा जा सकता है। यदि आपने कभी Array<Int>, Dictionary<String, Any> या Optional<T> का उपयोग किया है, तो आप पहले ही generics का सामना कर चुके हैं। इस लेख में, हम समझेंगे कि ये क्यों आवश्यक हैं, इन्हें सही तरीके से कैसे लागू करें, और iOS/macOS डेवलपमेंट के लिए व्यावहारिक उदाहरण देखेंगे।

Swift में Generics की आवश्यकता क्यों है?

मुख्य समस्या जो generics हल करते हैं, वह है विभिन्न डेटा प्रकारों के लिए एक ही कोड लिखने की आवश्यकता। इनके बिना, आपको Int, String, Double और उपयोगकर्ता-परिभाषित संरचनाओं के साथ काम करने के लिए अलग-अलग फ़ंक्शन बनाने होंगे। इससे कोड दोहराव, त्रुटियाँ और रखरखाव में जटिलता आती है।

Generics के प्रमुख लाभ:

\n
• टाइप सुरक्षा: कंपाइलर संकलन के समय प्रकारों की जाँच करता है, रनटाइम त्रुटियों को रोकता है।
\n
• कोड पुन: उपयोग: एक फ़ंक्शन या प्रकार किसी भी डेटा प्रकार के साथ काम करता है।
\n
• प्रदर्शन: Swift में generics विशेषज्ञता के माध्यम से कार्यान्वित किए जाते हैं — कंपाइलर प्रत्येक विशिष्ट प्रकार के लिए अनुकूलित कोड बनाता है, जो मैन्युअल रूप से डुप्लिकेट कोड लिखने के बराबर है।
\n
• पठनीयता और अमूर्तता: कोड अधिक संक्षिप्त और अभिव्यंजक हो जाता है।
\n

एक सरल उदाहरण देखें। मान लीजिए, हमें दो वेरिएबल के मानों को आपस में बदलने के लिए एक फ़ंक्शन चाहिए। Generics के बिना, हमें इस तरह लिखना होगा:

func swapInts(_ a: inout Int, _ b: inout Int) {\n    let temp = a\n    a = b\n    b = temp\n}\n\nfunc swapStrings(_ a: inout String, _ b: inout String) {\n    let temp = a\n    a = b\n    b = temp\n}\n// ... और इसी तरह प्रत्येक प्रकार के लिए

Generics के साथ, समाधान सार्वभौमिक हो जाता है:

func swapValues<T>(_ a: inout T, _ b: inout T) {\n    let temp = a\n    a = b\n    b = temp\n}\n\nvar x = 10\nvar y = 20\nswapValues(&x, &y) // Int के साथ काम करता है\n\nvar str1 = "Hello"\nvar str2 = "World"\nswapValues(&str1, &str2) // String के साथ काम करता है

जैसा कि आप देख सकते हैं, <T> एक प्रकार के लिए placeholder (प्लेसहोल्डर) है। कंपाइलर फ़ंक्शन को कॉल करते समय स्वचालित रूप से विशिष्ट प्रकार का अनुमान लगाता है।

Generic फ़ंक्शन और प्रकार

Generics का उपयोग न केवल फ़ंक्शन के साथ, बल्कि उपयोगकर्ता-परिभाषित प्रकारों: संरचनाओं, क्लासेस और एनुम के साथ भी किया जा सकता है।

Generic फ़ंक्शन

सरल placeholder के अलावा, आप प्रकार पर प्रतिबंध लगा सकते हैं। उदाहरण के लिए, एक फ़ंक्शन जो केवल उन प्रकारों के साथ काम करता है जो Equatable प्रोटोकॉल को लागू करते हैं:

func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {\n    for (index, item) in array.enumerated() {\n        if item == value {\n            return index\n        }\n    }\n    return nil\n}\n\nlet numbers = [1, 5, 3, 12]\nif let index = findIndex(of: 5, in: numbers) {\n    print("इंडेक्स मिला: \\(index)") // आउटपुट: इंडेक्स मिला: 1\n}

प्रतिबंध <T: Equatable> यह सुनिश्चित करता है कि प्रकार T के लिए == ऑपरेटर परिभाषित है।

Generic प्रकार (संरचनाएँ और क्लासेस)

आइए एक सरल स्टैक बनाएँ — एक डेटा संरचना जो LIFO (Last In, First Out) सिद्धांत पर काम करती है:

struct Stack<Element> {\n    private var items = [Element]()\n    \n    mutating func push(_ item: Element) {\n        items.append(item)\n    }\n    \n    mutating func pop() -> Element? {\n        return items.popLast()\n    }\n    \n    var top: Element? {\n        return items.last\n    }\n}\n\nvar intStack = Stack<Int>()\nintStack.push(10)\nintStack.push(20)\nprint(intStack.pop() ?? 0) // 20\n\nvar str