🔑 जेनेरिक्स का उपयोग करके Go में मैप से सॉर्टेड कीज़ (Sorted Keys) प्राप्त करें 🔗

जेनेरिक्स का उपयोग करके Go में मैप से सॉर्टेड कीज़ (Sorted Keys) प्राप्त करेंजेनेरिक्स का उपयोग करके Go में मैप से सॉर्टेड कीज़ (Sorted Keys) प्राप्त करें

Go में, मैप (maps) स्वाभाविक रूप से अव्यवस्थित (unordered) होते हैं। जब आप for range लूप का उपयोग करके किसी मैप पर पुनरावृत्ति (iterate) करते हैं, तो पुनरावृत्ति का क्रम रैंडम होता है। जेनेरिक्स से पहले, डेवलपर्स को मैप की कीज़ (keys) को निकालने और सॉर्ट करने के लिए बॉयलरप्लेट कोड या टाइप-विशिष्ट फ़ंक्शन लिखने पड़ते थे।

आधुनिक Go जेनेरिक्स और स्टैंडर्ड लाइब्रेरी पैकेजों (cmp और slices) के साथ, एक साफ, पुन: प्रयोज्य SortedKeys फ़ंक्शन लागू करना सीधा और संक्षिप्त है।

📑 विषय-सूची

💻 आधुनिक कार्यान्वयन (Go 1.21+) 🔗

package main

import (
	"cmp"
	"slices"
	"fmt"
)

// SortedKeys extracts all keys from a map and returns them in sorted order.
// It works for any map where the key type is ordered (ints, floats, strings).
func SortedKeys[K cmp.Ordered, V any](m map[K]V) []K {
	r := make([]K, 0, len(m))
	for k := range m {
		r = append(r, k)
	}
	slices.Sort(r)
	return r
}

func main() {
	// Example 1: Integer keys
	intMap := map[int]string{3: "three", 1: "one", 2: "two"}
	fmt.Println(SortedKeys(intMap))
	// Output: [1 2 3]

	// Example 2: String keys
	strMap := map[string]int{"banana": 2, "apple": 4, "cherry": 1}
	fmt.Println(SortedKeys(strMap))
	// Output: [apple banana cherry]
}

⚙️ यह कैसे काम करता है 🔗

  1. जेनेरिक टाइप बाधाएं (K cmp.Ordered, V any):
  2. स्लाइस का पूर्व-आवंटन (Pre-allocating the Slice):
  3. कीज़ निकालना:
  4. सॉर्टिंग (Sorting):

🚀 यह संस्करण 2020 के ड्राफ्ट से बेहतर क्यों है 🔗

जून 2020 में, जब Go जेनेरिक्स अभी भी डिज़ाइन ड्राफ्ट चरण में थे, डेवलपर्स को मैन्युअल रूप से sort.Interface को संतुष्ट करने वाले कस्टम टाइप्स को लागू करना पड़ता था:

// Old pre-Go 1.18 design draft approach (Obsolete)
type Ordered interface {
	type int, int8, ... // type lists in interfaces
}

type orderedSlice[T Ordered] []T
func (s orderedSlice[T]) Len() int           { return len(s) }
func (s orderedSlice[T]) Less(i, j int) bool { return s[i] < s[j] }
func (s orderedSlice[T]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

आज, आधुनिक Go प्रदान करता है:



💬 टिप्पणियाँ और चर्चा 🔗

क्या आपका कोई प्रश्न, दृष्टिकोण या सुझाव है? नीचे अपने विचार साझा करें। टिप्पणियाँ GitHub Discussions (विज्ञापन-मुक्त और स्पैम-मुक्त) द्वारा संचालित हैं—टिप्पणी करने या प्रतिक्रिया देने के लिए नीचे Sign in with GitHub पर क्लिक करें (निःशुल्क GitHub खाता बनाने में एक मिनट से भी कम समय लगता है)।



अंतिम अपडेट: 11 अक्टू॰ 2026.

अस्वीकरण (DISCLAIMER): इस साइट की सामग्री केवल सूचनात्मक और शैक्षिक उद्देश्यों के लिए है और यह चिकित्सा, मनोवैज्ञानिक, वित्तीय, निवेश, कर या कानूनी सलाह का गठन नहीं करती है। यहाँ प्रस्तुत विचार, संकलन और राय पूरी तरह से मेरे अपने हैं और मेरे नियोक्ता का प्रतिनिधित्व नहीं करते हैं। पुस्तकों, व्याख्यानों और लेखों के सारांश स्वतंत्र शैक्षिक टिप्पणियाँ हैं और उनके संबंधित लेखकों की बौद्धिक संपदा बने रहते हैं। संपादन, स्वरूपण और संश्लेषण में सहायता के लिए AI उपकरणों का उपयोग किया जा सकता है; यद्यपि सटीकता सुनिश्चित करने का हर संभव प्रयास किया जाता है, फिर भी त्रुटियाँ हो सकती हैं। गोपनीयता (PRIVACY): यह साइट किसी भी ट्रैकिंग कुकी का उपयोग नहीं करती है; ब्राउज़र लोकल स्टोरेज का उपयोग केवल वैकल्पिक भाषा और प्लेबैक-गति वरीयताओं को याद रखने के लिए किया जाता है, और Google Cloud पर होस्टिंग लॉग समग्र ट्रैफ़िक आँकड़ों के लिए आगंतुकों के IP पते, ब्राउज़र मेटाडेटा, अनुरोधित संसाधनों, पृष्ठ सहभागिता और रेफ़रल स्रोतों को संसाधित करते हैं। वैकल्पिक न्यूज़लेटर सदस्यता (Mailchimp), टिप्पणियों (giscus / GitHub Discussions) और मीडिया डाउनलोड/स्ट्रीमिंग (GitHub) के लिए उपयोग की जाने वाली तृतीय-पक्ष सेवाएँ अपनी संबंधित गोपनीयता नीतियों के अनुसार आगंतुकों के IP पते और कुकीज़ को संसाधित कर सकती हैं।