🔑 जेनेरिक्स का उपयोग करके 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):
   • K cmp.Ordered मैप कीज़ को उन टाइप्स तक सीमित करता है जो तुलना ऑपरेटरों (<, >, <=, >=) का समर्थन करते हैं, जैसे पूर्णांक (integers), फ़्लोट्स (floats) और स्ट्रिंग्स (strings)।
   • V any मैप के मानों (values) को किसी भी टाइप का होने की अनुमति देता है (any, interface{} के लिए एक उपनाम है)।
2. स्लाइस का पूर्व-आवंटन (Pre-allocating the Slice):
   • make([]K, 0, len(m)) मैप की लंबाई के बराबर क्षमता वाले स्लाइस को पहले से आवंटित करता है, जिससे अपेंड लूप के दौरान महंगे डायनेमिक मेमोरी री-एलोकेशन से बचा जा सकता है।
3. कीज़ निकालना:
   • for k := range m लूप सभी कीज़ को स्लाइस में एकत्र करता है।
4. सॉर्टिंग (Sorting):
   • slices.Sort(r) Go के अत्यधिक अनुकूलित सॉर्टिंग एल्गोरिदम का उपयोग करके कीज़ के स्लाइस को इन-प्लेस (उसी स्थान पर) सॉर्ट करता है।

🚀 यह संस्करण 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 प्रदान करता है:

• cmp.Ordered (Go 1.21 से स्टैंडर्ड लाइब्रेरी में): ऑर्डर किए गए टाइप्स के लिए कस्टम इंटरफ़ेस टाइप सेट को परिभाषित करने की आवश्यकता को समाप्त करता है।
• slices.Sort (Go 1.21 से स्टैंडर्ड लाइब्रेरी में): बॉयलरप्लेट sort.Interface कार्यान्वयन (Len, Less, Swap) को समाप्त करता है, जिससे स्लाइस सॉर्टिंग एक एकल, पठनीय फ़ंक्शन कॉल बन जाती है।