Go में map से keys का slice कैसे निकालें: 2025 गाइड

Go डेवलपर की सबसे बड़ी समस्या: map से सभी keys जल्दी कैसे निकालें?

क्या आपने कभी Go में ऐसा कोड लिखा है?

m := map[string]int{"go": 1, "python": 2, "rust": 3}\nkeys := make([]string, 0, len(m))\nfor k := range m {\n    keys = append(keys, k)\n}\n

अगर हाँ, तो आप अकेले नहीं हैं। map से keys का slice निकालना Stack Overflow पर Go कैटेगरी में सबसे लोकप्रिय सवालों में से एक है। इस सवाल को हज़ारों बार देखा जाता है, और इसके नीचे दर्जनों जवाब होते हैं। यह कोई आश्चर्य की बात नहीं है: Go में Python या JavaScript की तरह कोई बिल्ट-इन keys() फंक्शन नहीं है। हर बार हमें खुद से कोड लिखना पड़ता है।

लेकिन 2025 ने कुछ बदलाव लाए हैं। Go 1.22 के जेनेरिक्स और नए इडियम्स के साथ, अब और भी शानदार समाधान उपलब्ध हैं। इस आर्टिकल में हम map से keys का slice निकालने के सभी तरीकों पर चर्चा करेंगे—क्लासिक तरीकों से लेकर आधुनिक बेस्ट प्रैक्टिसेज तक। चलिए शुरू करते हैं!

Go में बिल्ट-इन keys() क्यों नहीं है?

कोड में कूदने से पहले, आइए Go की फिलॉसफी को समझें। Go एक मिनिमलिस्टिक भाषा है। इसके निर्माता जानबूझकर ऐसे फंक्शन नहीं जोड़ते जिन्हें एक लाइन में लागू किया जा सके। for k := range m ही map पर इटरेट करने का बिल्ट-इन तरीका है। लेकिन समस्या यह है कि:

\n
• Keys का क्रम गारंटीड नहीं है (और यह एक फीचर है, बग नहीं)
\n
• "सब कुछ slice में इकट्ठा करो" के लिए कोई सिंटैक्स शुगर नहीं है
\n
• जेनेरिक्स केवल 1.18 में आए, और 1.22 तक स्थिर हुए
\n

यही कारण है कि Go कम्युनिटी ने कई पैटर्न विकसित किए हैं। आइए उनकी तुलना करें।

तरीका 1: क्लासिक लूप (बेसिक लेवल)

सबसे आसान और समझने वाला तरीका—वही जो हमने शुरुआत में दिखाया था। यह Go के किसी भी वर्जन में काम करता है।

func Keys(m map[string]int) []string {\n    keys := make([]string, 0, len(m))\n    for k := range m {\n        keys = append(keys, k)\n    }\n    return keys\n}\n

फायदे:

\n
• पारदर्शिता—कोई भी नौसिखिया समझ सकता है कि क्या हो रहा है
\n
• Go वर्जन पर कोई निर्भरता नहीं
\n
• आसानी से मॉडिफाई किया जा सकता है (जैसे, फिल्टरेशन जोड़ना)
\n

नुकसान:

\n
• हर map के लिए बहुत सारा बॉयलरप्लेट कोड
\n
• हर टाइप के लिए अलग फंक्शन लिखना पड़ता है
\n

निष्कर्ष: सीखने के उदाहरणों या एक बार के कामों के लिए बढ़िया। लेकिन प्रोडक्शन कोड में सार्वभौमिकता चाहिए।

तरीका 2: जेनेरिक्स (Go 1.18+)

जेनेरिक्स के आने के बाद, किसी भी टाइप की keys के लिए एक फंक्शन लिखना संभव हो गया।

func Keys[K comparable, V any](m map[K]V) []K {\n    keys := make([]K, 0, len(m))\n    for k := range m {\n        keys = append(keys, k)\n    }\n    return keys\n}\n\n// उपयोग:\nm := map[string]int{"a": 1, "b": 2}\nkeys := Keys(m) // []string{"a", "b"}\n

सुंदर है, है ना? एक फंक्शन—और सब काम करता है। Go 1.22 ने जेनेरिक्स को और भी स्थिर बना दिया है, इसलिए यह तरीका नए प्रोजेक्ट्स के लिए अनुशंसित है।

महत्वपूर्ण: keys को comparable होना चाहिए। यह सभी मानक टाइप्स (string, int, float, बिना slice वाला struct, आदि) के लिए ऑटोमैटिकली पूरा होता है।

तरीका 3: reflect का उपयोग (असामान्य मामलों के लिए)

कभी-कभी ऐसे map के साथ काम करना पड़ता है जिसका टाइप केवल रनटाइम पर पता चलता है। यहाँ reflect पैकेज काम आता है।

func KeysReflect(m interface{}) []interface{} {\n    v := reflect.ValueOf(m)\n    if v.Kind() != reflect.Map {\n        return nil\n    }\n    keys := make([]interface{}, v.Len())\n    for i, k := range v.MapKeys() {\n        keys[i] = k.Interface()\n    }\n    return keys\n}\n

कब उपयोग करें:

\n
• अज्ञात स्ट्रक्चर्स के सीरियलाइज़ेशन/डीसीरियलाइज़ेशन में
\n
• जनरल-पर्पज लाइब्रेरीज़ में
\n
• जब map का टाइप बाहरी स्रोत (JSON, YAML) से आता है