🔑 Obtener las claves ordenadas de un mapa en Go usando genéricos 🔗

En Go, los mapas son intrínsecamente desordenados. Cuando iteras sobre un mapa utilizando un bucle for range, el orden de iteración es aleatorio. Antes de la llegada de los genéricos, los desarrolladores tenían que escribir código repetitivo o funciones específicas para cada tipo con el fin de extraer y ordenar las claves de un mapa.

Con los genéricos del Go moderno y los paquetes de la biblioteca estándar (cmp y slices), implementar una función SortedKeys limpia y reutilizable resulta directo y conciso.

📑 Tabla de Contenidos 🔗

💻 La implementación moderna (Go 1.21+) 🔗

package main

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

// SortedKeys extrae todas las claves de un mapa y las devuelve ordenadas.
// Funciona para cualquier mapa cuyo tipo de clave sea ordenable (enteros, flotantes, cadenas).
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() {
	// Ejemplo 1: Claves enteras
	intMap := map[int]string{3: "three", 1: "one", 2: "two"}
	fmt.Println(SortedKeys(intMap))
	// Salida: [1 2 3]

	// Ejemplo 2: Claves de cadena
	strMap := map[string]int{"banana": 2, "apple": 4, "cherry": 1}
	fmt.Println(SortedKeys(strMap))
	// Salida: [apple banana cherry]
}

⚙️ Cómo funciona 🔗

1. Restricciones de tipos genéricos (K cmp.Ordered, V any):
   • K cmp.Ordered restringe las claves del mapa a tipos que admiten operadores de comparación (<, >, <=, >=), como números enteros, números en coma flotante y cadenas de texto.
   • V any permite que los valores del mapa sean de cualquier tipo (any es un alias de interface{}).
2. Preasignación del slice:
   • make([]K, 0, len(m)) preasigna un slice con una capacidad igual a la longitud del mapa, evitando costosas reasignaciones dinámicas de memoria durante el bucle append.
3. Extracción de las claves:
   • El bucle for k := range m recopila todas las claves dentro del slice.
4. Ordenación:
   • slices.Sort(r) ordena el slice de claves in situ utilizando los algoritmos de ordenación altamente optimizados de Go.

🚀 Por qué esta versión es mejor que el borrador de 2020 🔗

En junio de 2020, cuando los genéricos de Go aún se encontraban en fase de borrador de diseño, los desarrolladores tenían que implementar manualmente tipos personalizados que satisficieran sort.Interface:

// Enfoque antiguo del borrador de diseño previo a Go 1.18 (Obsoleto)
type Ordered interface {
	type int, int8, ... // listas de tipos en 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] }

Hoy en día, el Go moderno ofrece:

• cmp.Ordered (en la biblioteca estándar desde Go 1.21): Elimina la necesidad de definir conjuntos de tipos de interfaz personalizados para tipos ordenables.
• slices.Sort (en la biblioteca estándar desde Go 1.21): Elimina la implementación repetitiva de sort.Interface (Len, Less, Swap), convirtiendo la ordenación de un slice en una única llamada a función clara y legible.