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

परिचय: Generics क्या हैं और ये Go में क्यों आए?

लंबे समय तक, Go (Golang) समुदाय जेनेरिक्स (सामान्यीकृत प्रोग्रामिंग) के बिना काम चलाता रहा। डेवलपर्स सख्त टाइपिंग की सीमाओं को पार करने के लिए इंटरफ़ेस, खाली interface{} और कोड जनरेशन का उपयोग करते थे। Go संस्करण 1.18 (फरवरी 2022) में, भाषा में अंततः जेनेरिक्स जोड़े गए — एक शक्तिशाली उपकरण जो आपको टाइप सुरक्षा खोए बिना विभिन्न डेटा प्रकारों के साथ काम करने वाले फ़ंक्शन और संरचनाएँ लिखने की अनुमति देता है।

इस लेख में, हम समझेंगे कि Go में Generics की आवश्यकता क्यों है, वे कैसे काम करते हैं, और व्यवहार में उनका उपयोग करना सीखेंगे। यह सामग्री शुरुआती डेवलपर्स के लिए है जो Go की मूल बातें: वेरिएबल, फ़ंक्शन और स्लाइस से पहले से परिचित हैं।

Go में जेनेरिक्स की आवश्यकता क्यों है?

कल्पना करें कि आपको एक फ़ंक्शन लिखना है जो संख्याओं के स्लाइस में न्यूनतम मान ढूँढता है। जेनेरिक्स के बिना, आपको int, float64 और अन्य प्रकारों के लिए अलग-अलग फ़ंक्शन लिखने होंगे:

// जेनेरिक्स के बिना — तीन समान फ़ंक्शनfunc MinInt(a, b int) int {    if a < b {        return a    }    return b}

func MinFloat64(a, b float64) float64 {    if a < b {        return a    }    return b}

इससे कोड की पुनरावृत्ति होती है। पहले, इस समस्या को interface{} और टाइप कास्टिंग के माध्यम से हल किया जाता था, लेकिन यह दृष्टिकोण संकलन चरण में सुरक्षा खो देता था:

func Min(a, b interface{}) interface{} {    // तुलना और कास्टिंग — गलती करना आसान    return a}

जेनेरिक्स तीन मुख्य समस्याओं का समाधान करते हैं:

• टाइप सुरक्षा — टाइप की त्रुटियाँ संकलन चरण में ही पकड़ी जाती हैं।
• पुनरावृत्ति को समाप्त करना — एक फ़ंक्शन किसी भी प्रकार के साथ काम करता है।
• कोड पठनीयता — स्पष्ट रूप से बताता है कि कौन से प्रकार समर्थित हैं।

सिंटैक्स की मूल बातें: type parameters और constraints

Go में जेनेरिक्स दो अवधारणाओं पर आधारित हैं: प्रकार पैरामीटर (type parameters) और बाधाएँ (constraints)।

प्रकार पैरामीटर

प्रकार पैरामीटर फ़ंक्शन या प्रकार के नाम के बाद वर्गाकार कोष्ठक में निर्दिष्ट किए जाते हैं। परंपरा के अनुसार, अक्सर अक्षर T (Type से) का उपयोग किया जाता है, लेकिन किसी भी नाम का उपयोग किया जा सकता है:

// एक प्रकार पैरामीटर T के साथ फ़ंक्शनfunc Print[T any](value T) {    fmt.Println(value)}

// उपयोगPrint[int](42)      // स्पष्ट रूप से प्रकार निर्दिष्ट करनाPrint("Hello")      // कंपाइलर स्वचालित रूप से प्रकार का अनुमान लगाता है

कीवर्ड any खाली इंटरफ़ेस interface{} का उपनाम है। इसका मतलब है कि फ़ंक्शन किसी भी प्रकार को स्वीकार करता है।

बाधाएँ (constraints)

बाधाएँ यह निर्धारित करती हैं कि जेनेरिक के साथ किन प्रकारों का उपयोग किया जा सकता है। उदाहरण के लिए, संख्याओं की तुलना करने के लिए, प्रकार को < और > ऑपरेटरों का समर्थन करना होगा। संख्यात्मक प्रकारों के लिए अंतर्निहित बाधाएँ पैकेज golang.org/x/exp/constraints में हैं:

import "golang.org/x/exp/constraints"

// बाधा — केवल पूर्णांकfunc Sum[T constraints.Integer](numbers []T) T {    var total T    for _, n := range numbers {        total += n    }    return total}

आप इंटरफ़ेस के माध्यम से अपनी स्वयं की बाधाएँ भी बना सकते हैं:

// स्वयं की बाधा: प्रकार में एक String() विधि होनी चाहिएtype Stringer interface {    String() string}

func Describe[T Stringer](value T) string {    return "Value: " + value.String()}

Generics के उपयोग के व्यावहारिक उदाहरण

आइए कुछ वास्तविक परिदृश्यों पर विचार करें जहाँ जेनेरिक्स कोड को काफी सरल बनाते हैं।

1. स्लाइस में खोज के लिए सार्वभौमिक फ़ंक्शन

// स्लाइस में तत्व का इंडेक्स ढूँढता है। न मिलने पर -1 लौटाता है।func Index[T comparable](slice []T, target T