Swift में Generics शुरुआती लोगों के लिए: क्यों ज़रूरी हैं और कैसे उपयोग करें

परिचय: Swift में Generics के बिना क्यों नहीं चलेगा?

कल्पना करें कि आपको एक फंक्शन लिखना है जो दो संख्याओं को जोड़ता है। फिर दो स्ट्रिंग्स को जोड़ने के लिए एक फंक्शन। और फिर ऐरे के लिए। सामान्यीकृत प्रोग्रामिंग (Generics) के बिना, आपको प्रत्येक डेटा प्रकार के लिए कोड का एक अलग संस्करण बनाना होगा। इससे न केवल कोड की मात्रा बढ़ती है, बल्कि इसका रखरखाव भी जटिल हो जाता है।

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

सरल शब्दों में Generics क्या है?

Generics (सामान्यीकरण) कोड लिखने का एक तरीका है जो किसी भी डेटा प्रकार के साथ काम करता है, बिना Swift की सख्त टाइपिंग का त्याग किए। किसी विशिष्ट प्रकार (जैसे Int या String) को निर्दिष्ट करने के बजाय, आप एक प्लेसहोल्डर (अक्सर अक्षर T) का उपयोग करते हैं, जो फंक्शन को कॉल करने या संरचना बनाने के दौरान वास्तविक प्रकार से बदल दिया जाता है।

Generics के बिना समस्या

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

func swapInts(_ a: inout Int, _ b: inout Int) {    let temp = a    a = b    b = temp}

func swapStrings(_ a: inout String, _ b: inout String) {    let temp = a    a = b    b = temp}

यह स्पष्ट दोहराव है। यदि Double या उपयोगकर्ता-परिभाषित प्रकारों को बदलने की आवश्यकता होती है, तो फंक्शन की संख्या बढ़ती जाएगी।

Generics के साथ समाधान

एक सार्वभौमिक फंक्शन पिछले सभी को बदल देगा:

func swapValues<T>(_ a: inout T, _ b: inout T) {    let temp = a    a = b    b = temp}

// उपयोग:var x = 10var y = 20swapValues(&x, &y) // x = 20, y = 10

var firstName = "अन्ना"var lastName = "इवानोवा"swapValues(&firstName, &lastName) // firstName = "इवानोवा"

कोण कोष्ठक <T> प्रकार के प्लेसहोल्डर की घोषणा करते हैं। कंपाइलर स्वचालित रूप से निर्धारित करता है कि पहले मामले में T Int है और दूसरे में String है। कोड संक्षिप्त और सुरक्षित हो जाता है।

Generics का उपयोग कैसे करें: मुख्य परिदृश्य

Swift में Generics का उपयोग फंक्शन, स्ट्रक्चर, क्लास, एनुम और प्रोटोकॉल में किया जाता है। आइए सबसे सामान्य मामलों पर विचार करें।

1. सामान्यीकृत फंक्शन

हमने पहले ही swapValues का उदाहरण देखा है। लेकिन आप आगे जा सकते हैं - एक फंक्शन बनाएं जो किसी ऐरे में एलिमेंट का इंडेक्स ढूंढता है:

func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {    for (index, element) in array.enumerated() {        if element == value {            return index        }    }    return nil}

let numbers = [1, 5, 9, 12]if let index = findIndex(of: 9, in: numbers) {    print("इंडेक्स: \\(index)") // इंडेक्स: 2}

<T: Equatable> पर ध्यान दें। यह एक प्रकार बाधा (type constraint) है। हम कह रहे हैं: "T को Equatable प्रोटोकॉल का पालन करना चाहिए ताकि हम == ऑपरेटर का उपयोग कर सकें"। इस बाधा के बिना, कोड संकलित नहीं होगा।

2. सामान्यीकृत प्रकार (स्ट्रक्चर और क्लास)

आइए एक सरल "स्टैक" (LIFO) संरचना बनाएं जो किसी भी प्रकार को संग्रहीत कर सके:

struct Stack<Element> {    private var items: [Element] = []

    mutating func push(_ item: Element) {        items.append(item)    }

    mutating func pop() -> Element? {        return items.popLast()    }

    func peek() -> Element? {        return items.last    }}

// उपयोग:var intStack = Stack<Int>()intStack.push(1)intStack.push(2)print(intStack.pop