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

Swift में Generics क्या हैं और इनकी आवश्यकता क्यों है

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

कल्पना करें कि आपको एक फ़ंक्शन लिखना है जो दो मानों को आपस में बदलता है। 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}

Generics के साथ यह एक पंक्ति में किया जाता है:

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

var x = 10, y = 20swapValues(&x, &y) // Int के साथ काम करता है

var str1 = "Hello", str2 = "World"swapValues(&str1, &str2) // String के साथ काम करता है

Generics के मुख्य लाभ

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

Generic फ़ंक्शन और प्रकार पैरामीटर

Generic फ़ंक्शन को कोण कोष्ठक <> के साथ घोषित किया जाता है, जिसके अंदर प्रकार पैरामीटर निर्दिष्ट किया जाता है (आमतौर पर T अक्षर से दर्शाया जाता है, लेकिन किसी भी नाम का उपयोग किया जा सकता है)। प्रकार पैरामीटर एक placeholder बन जाता है, जो फ़ंक्शन को कॉल करने पर वास्तविक प्रकार से बदल दिया जाता है।

उदाहरण: ऐरे में तत्व खोजना

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, 3, 12, 7]if let index = findIndex(of: 12, in: numbers) {    print("संख्या 12 का सूचकांक: \\(index)") // संख्या 12 का सूचकांक: 3}

let names = ["अन्ना", "बोरिस", "विक्टर"]if let index = findIndex(of: "बोरिस", in: names) {    print("नाम बोरिस का सूचकांक: \\(index)") // नाम बोरिस का सूचकांक: 1}

बाधा T: Equatable पर ध्यान दें। यह एक type constraint है — हम आवश्यकता करते हैं कि प्रकार T प्रोटोकॉल Equatable का समर्थन करे, अन्यथा तुलना ऑपरेशन == संभव नहीं होगा।

Generic प्रकार: संरचनाएँ, क्लास और एनुम

Generics न केवल फ़ंक्शन के साथ बल्कि उपयोगकर्ता-परिभाषित प्रकारों के साथ भी काम करते हैं। यह सार्वभौमिक डेटा कंटेनर बनाने की अनुमति देता है।

Generic स्टैक बनाना

क्लासिक उदाहरण — डेटा संरचना Stack (स्टैक), जो किसी भी प्रकार के साथ काम करती है:

struct Stack<Element> {    private var items: [Element] = []        mutating func push(_ item: Element) {        items.append(item)    }        @discardableResult    mutating func pop() -> Element? {        return items.popLast()    }        func peek() -> Element? {        return items.last    }        var isEmpty: Bool {        return items.isEmpty    }}

// उपयोगvar intStack = Stack<Int>()intStack.push(10)intStack.push(20)print(intStack.pop() ?? "") // 20

var stringStack = Stack<String>()stringStack.push("Swift")stringStack.push("Generics")print(stringStack.pop() ?? "") // Generics

Generic एनुम

एनुम भी हो सकते हैं ```