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

परिचय: Generics क्या हैं और Swift में वे क्यों महत्वपूर्ण हैं

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

इस लेख में, हम समझेंगे कि Swift में Generics क्यों आवश्यक हैं, वे व्यवहार में कैसे काम करते हैं, और iOS/macOS डेवलपमेंट के लिए उदाहरण दिखाएंगे। यह सामग्री शुरुआती और अनुभवी डेवलपर्स दोनों के लिए उपयोगी होगी जो अपने ज्ञान को संरचित करना चाहते हैं।

1. Swift में Generics क्यों आवश्यक हैं?

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

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}

Generics के साथ, यह कार्य एक सार्वभौमिक फ़ंक्शन से हल हो जाता है:

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

var x = 10, y = 20swapValues(&x, &y) // x = 20, y = 10

var name1 = "Alice", name2 = "Bob"swapValues(&name1, &name2) // name1 = "Bob", name2 = "Alice"

Generics के लाभ:

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

2. Generic-फ़ंक्शन: सिंटैक्स और उदाहरण

Generic-फ़ंक्शन को कोण कोष्ठक <T> के साथ घोषित किया जाता है, जहाँ T प्रकार के लिए एक प्लेसहोल्डर है। आप किसी भी पहचानकर्ता का उपयोग कर सकते हैं: T, Element, Value आदि।

मूल उदाहरण: तत्व का इंडेक्स खोजना

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

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

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

एकाधिक प्रकार पैरामीटर

आप कई प्रकार पैरामीटर का उपयोग कर सकते हैं:

func combine<T, U>(_ first: T, with second: U) -> String {    return "\\(first) + \\(second)"}

let result = combine(42, with: "उत्तर")print(result) // 42 + उत्तर

3. Generic-प्रकार: सामान्यीकृत संरचनाएं और क्लास बनाना

Generics न केवल फ़ंक्शन पर, बल्कि प्रकारों पर भी लागू होते हैं। सबसे लोकप्रिय उदाहरण Array<Element> है। आइए अपनी खुद की generic-संरचना बनाएं - एक स्टैक (LIFO):

struct Stack<Element> {    private var items: [Element] = []        mutating func push(_ item: Element) {        items.append(item