🔑 Obtenir les clés triées d’une map en Go avec les génériques 🔗

En Go, les maps sont par nature non ordonnées. Lorsque vous parcourez une map à l’aide d’une boucle for range, l’ordre d’itération est aléatoire. Avant l’arrivée des génériques, les développeurs devaient écrire du code répétitif (boilerplate) ou des fonctions spécifiques à chaque type pour extraire et trier les clés d’une map.

Avec les génériques du Go moderne et les paquets de la bibliothèque standard (cmp et slices), l’implémentation d’une fonction SortedKeys propre et réutilisable est simple et concise.

📑 Table des Matières 🔗

💻 L’implémentation moderne (Go 1.21+) 🔗

package main

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

// SortedKeys extrait toutes les clés d'une map et les retourne par ordre trié.
// Elle fonctionne pour toute map dont le type de clé est ordonné (entiers, flottants, chaînes).
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() {
	// Exemple 1 : Clés entières
	intMap := map[int]string{3: "three", 1: "one", 2: "two"}
	fmt.Println(SortedKeys(intMap))
	// Sortie : [1 2 3]

	// Exemple 2 : Clés sous forme de chaînes de caractères
	strMap := map[string]int{"banana": 2, "apple": 4, "cherry": 1}
	fmt.Println(SortedKeys(strMap))
	// Sortie : [apple banana cherry]
}

⚙️ Comment ça marche 🔗

1. Contraintes de types génériques (K cmp.Ordered, V any) :
   • K cmp.Ordered restreint les clés de la map aux types qui prennent en charge les opérateurs de comparaison (<, >, <=, >=), tels que les entiers, les nombres à virgule flottante et les chaînes de caractères.
   • V any permet aux valeurs de la map d’être de n’importe quel type (any est un alias pour interface{}).
2. Pré-allocation de la tranche (slice) :
   • make([]K, 0, len(m)) pré-alloue une tranche avec une capacité égale à la taille de la map, évitant ainsi des réallocations dynamiques de mémoire coûteuses pendant la boucle d’ajout (append).
3. Extraction des clés :
   • La boucle for k := range m rassemble toutes les clés dans la tranche.
4. Tri :
   • slices.Sort(r) trie la tranche de clés sur place (in-place) en utilisant les algorithmes de tri hautement optimisés de Go.

🚀 Pourquoi cette version est meilleure que le brouillon de 2020 🔗

En juin 2020, lorsque les génériques de Go n’en étaient encore qu’au stade de brouillon de conception, les développeurs devaient implémenter manuellement des types personnalisés satisfaisant sort.Interface :

// Ancienne approche issue du brouillon de conception pré-Go 1.18 (Obsolète)
type Ordered interface {
	type int, int8, ... // listes de types dans les 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] }

Aujourd’hui, le Go moderne fournit :

• cmp.Ordered (bibliothèque standard depuis Go 1.21) : Élimine le besoin de définir des ensembles de types d’interface personnalisés pour les types ordonnés.
• slices.Sort (bibliothèque standard depuis Go 1.21) : Élimine l’implémentation répétitive de sort.Interface (Len, Less, Swap), faisant du tri d’une tranche un simple appel de fonction lisible.