🔑 Como Obter Chaves Ordenadas de um Map em Go Usando Generics 🔗

Em Go, os mapas (map) são inerentemente desordenados. Quando você itera sobre um mapa usando um loop for range, a ordem de iteração é randomizada. Antes dos generics, os desenvolvedores precisavam escrever código repetitivo (boilerplate) ou funções específicas para cada tipo a fim de extrair e ordenar as chaves de um mapa.

Com os generics modernos do Go e os pacotes da biblioteca padrão (cmp e slices), implementar uma função SortedKeys limpa e reutilizável é simples e conciso.

📑 Índice 🔗

💻 A Implementação Moderna (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]
}

⚙️ Como Funciona 🔗

1. Restrições de Tipo Genérico (K cmp.Ordered, V any):
   • K cmp.Ordered restringe as chaves do mapa a tipos que suportam operadores de comparação (<, >, <=, >=), como inteiros, números de ponto flutuante e strings.
   • V any permite que os valores do mapa sejam de qualquer tipo (any é um apelido para interface{}).
2. Pré-alocação do Slice:
   • make([]K, 0, len(m)) pré-aloca um slice com capacidade igual ao tamanho do mapa, evitando realocações dinâmicas de memória custosas durante o loop de append.
3. Extração das Chaves:
   • O loop for k := range m coleta todas as chaves no slice.
4. Ordenação:
   • slices.Sort(r) ordena o slice de chaves in-place (no próprio local) usando os algoritmos de ordenação altamente otimizados do Go.

🚀 Por Que Esta Versão é Melhor que o Rascunho de 2020 🔗

Em junho de 2020, quando os generics do Go ainda estavam na fase de proposta de design, os desenvolvedores precisavam implementar manualmente tipos personalizados que satisfizessem 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] }

Hoje, o Go moderno oferece:

• cmp.Ordered (na biblioteca padrão desde o Go 1.21): Elimina a necessidade de definir conjuntos de tipos personalizados em interfaces para tipos ordenáveis.
• slices.Sort (na biblioteca padrão desde o Go 1.21): Elimina a implementação repetitiva de sort.Interface (Len, Less, Swap), tornando a ordenação de slices uma única chamada de função legível.