🔑 Ottenere le chiavi ordinate di una mappa in Go usando i Generics 🔗

In Go, le mappe sono intrinsecamente non ordinate. Quando si itera su una mappa utilizzando un ciclo for range, l’ordine di iterazione viene randomizzato. Prima dell’introduzione dei generics, gli sviluppatori dovevano scrivere codice ripetitivo (boilerplate) o funzioni specifiche per ogni tipo per estrarre e ordinare le chiavi di una mappa.

Con i moderni generics di Go e i pacchetti della libreria standard (cmp e slices), implementare una funzione SortedKeys pulita e riutilizzabile è immediato e conciso.

📑 Indice 🔗

💻 L’implementazione moderna (Go 1.21+) 🔗

package main

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

// SortedKeys estrae tutte le chiavi da una mappa e le restituisce in ordine crescente.
// Funziona per qualsiasi mappa in cui il tipo della chiave sia ordinabile (int, float, string).
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() {
	// Esempio 1: Chiavi intere
	intMap := map[int]string{3: "three", 1: "one", 2: "two"}
	fmt.Println(SortedKeys(intMap))
	// Output: [1 2 3]

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

⚙️ Come funziona 🔗

1. Vincoli di tipo generici (K cmp.Ordered, V any):
   • K cmp.Ordered limita le chiavi della mappa ai tipi che supportano gli operatori di confronto (<, >, <=, >=), come numeri interi, numeri in virgola mobile e stringhe.
   • V any consente ai valori della mappa di essere di qualsiasi tipo (any è un alias per interface{}).
2. Pre-allocazione della Slice:
   • make([]K, 0, len(m)) pre-alloca una slice con una capacità pari alla lunghezza della mappa, evitando costose riallocazioni dinamiche di memoria durante il ciclo di append.
3. Estrazione delle chiavi:
   • Il ciclo for k := range m raccoglie tutte le chiavi all’interno della slice.
4. Ordinamento:
   • slices.Sort(r) ordina la slice di chiavi direttamente sul posto (in-place) utilizzando gli algoritmi di ordinamento altamente ottimizzati di Go.

🚀 Perché questa versione è migliore della bozza del 2020 🔗

Nel giugno 2020, quando i generics di Go erano ancora nella fase di bozza progettuale, gli sviluppatori dovevano implementare manualmente tipi personalizzati che soddisfacessero sort.Interface:

// Vecchio approccio della bozza pre-Go 1.18 (Obsoleto)
type Ordered interface {
	type int, int8, ... // liste di tipi nelle interfacce
}

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] }

Oggi, il Go moderno fornisce:

• cmp.Ordered (libreria standard da Go 1.21): Elimina la necessità di definire insiemi di tipi di interfaccia personalizzati per i tipi ordinabili.
• slices.Sort (libreria standard da Go 1.21): Elimina l’implementazione ripetitiva di sort.Interface (Len, Less, Swap), rendendo l’ordinamento di una slice una singola e leggibile chiamata di funzione.