Algoritmos Genéricos: Paquetes slices, maps y cmp

Go 1.21 añadió slices, maps y cmp - paquetes de la biblioteca estándar con enfoque genérico para ordenar, buscar, clonar y comparar de tres vías.

Úsalos antes que helpers personalizados; amplía con tus propios genéricos solo para la lógica de dominio que no cubran.

Resumen

slices opera sobre []E con restricciones como cmp.Ordered o comparable.

maps proporciona copia, eliminación e igualdad para map[K]V.

cmp define Ordered, Compare y Or para construir restricciones y comparadores.

Los algoritmos personalizados siguen los mismos patrones: un parámetro de tipo para elementos, parámetros separados para claves y valores cuando sea necesario.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

import (
    "cmp"
    "slices"
)
 
func TopN[T cmp.Ordered](data []T, n int) []T {
    if n <= 0 {
        return nil
    }
    cp := slices.Clone(data)
    slices.Sort(cp)
    if n > len(cp) {
        n = len(cp)
    }
    return cp[len(cp)-n:]
}

Cuándo recurrir a esto:

• Ordenación, búsqueda binaria, compactación, inserción, eliminación en slices.
• Clonación o fusión de mapas sin bucles manuales.
• Construcción de restricciones con cmp.Ordered en lugar de copiar uniones grandes.

Ejemplo de Trabajo

package main
 
import (
    "cmp"
    "fmt"
    "maps"
    "slices"
)
 
type User struct {
    Name string
    Age  int
}
 
func main() {
    nums := []int{3, 1, 4, 1, 5}
    slices.Sort(nums)
    fmt.Println(nums)
    fmt.Println(slices.BinarySearch(nums, 4))
 
    m1 := map[string]int{"a": 1, "b": 2}
    m2 := maps.Clone(m1)
    m2["c"] = 3
    fmt.Println(maps.Equal(m1, m2))
 
    users := []User{{"ann", 30}, {"bob", 25}}
    slices.SortFunc(users, func(a, b User) int {
        return cmp.Compare(a.Age, b.Age)
    })
    fmt.Println(users)
}

Lo que esto demuestra:

• slices.Sort requiere elementos ordenables; SortFunc acepta comparadores personalizados que devuelven el signo de cmp.
• maps.Clone y maps.Equal evitan la copia/igualdad hechas a mano.
• La ordenación de structs usa cmp.Compare en los campos, no == en structs a menos que sean completamente comparables y ese sea el orden deseado.

Inmersión Profunda

Cómo Funciona

• Las funciones genéricas de la biblioteca estándar se implementan una vez en la biblioteca y se monomorfizan en tus puntos de llamada.
• Las funciones de slices mutan los slices en el lugar a menos que el nombre diga Clone o devuelva un nuevo slice.
• Las funciones de maps no copian valores en profundidad; los punteros y slices dentro de los valores se aliásan como una asignación de mapa ordinaria.
• cmp.Compare devuelve -1, 0 o 1 para tipos ordenados y es el tipo de retorno preferido del comparador para slices.SortFunc.

Puntos Destacados de slices

Puntos Destacados de maps

Puntos Destacados de cmp

Notas de Go

// Ordenación de claves múltiples con cmp.Or
slices.SortFunc(records, func(a, b Record) int {
    return cmp.Or(
        cmp.Compare(a.Region, b.Region),
        cmp.Compare(a.Name, b.Name),
    )
})

• Prefiere slices.SortFunc sobre sort.Slice para código nuevo - firmas de comparador más claras.
• Para requisitos de ordenación estable, comprueba si slices.SortStableFunc se ajusta a tu versión de Go y úsalo cuando elementos iguales deban mantener el orden de entrada.
• Las transformaciones genéricas personalizadas Map siguen siendo útiles: func Map[T, U any](in []T, f func(T) U) []U.

Trampas

• Ordenar con == en structs - Usa SortFunc con orden de campos explícito. Solución: cmp.Or en campos.
• Asumir que maps.Clone hace copia profunda - Los valores se aliásan. Solución: clona estructuras anidadas explícitamente cuando sea necesario.
• Búsqueda binaria en slice no ordenado - Resultados de posición indefinidos. Solución: ordena primero o documenta la precondición.
• Reutilizar restricciones de unión localmente - Desviación de la biblioteca estándar. Solución: importa cmp.Ordered.
• Mutar el slice durante un bucle range en un algoritmo personalizado - Omite elementos o provoca condiciones de carrera. Solución: bucles basados en índices o recopila índices primero.
• Pasar un mapa nulo a maps.Copy - Pánico al escribir en un mapa nulo. Solución: dst = make(map[K]V) antes de copiar.

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de Genéricos - Introducción a slices.Contains
• Parámetros de Tipo e Interfaces de Restricción - Definición de cmp.Ordered
• Conjuntos de Tipos y la Restricción comparable - maps.Equal vs ==
• Estructuras de Datos Genéricas: Conjuntos, Colas, Mapas - Contenedores que usan estos helpers
• Implicaciones de Rendimiento de los Genéricos - Costo de ordenación e inlining

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado Green Tea GC, go fix modernizers - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica los objetivos de placa en la compilación), wazero (última - verifica en la compilación) y golangci-lint (última - verifica el conjunto de linters en la compilación).