Algoritmos Genéricos: Pacotes slices, maps & cmp

Go 1.21 adicionou slices, maps e cmp - pacotes da biblioteca padrão focados em genéricos para ordenação, busca, clonagem e comparação de três vias.

Use-os antes de helpers customizados; expanda com seus próprios genéricos apenas para a lógica de domínio que eles não cobrem.

Resumo

slices opera em []E com restrições como cmp.Ordered ou comparable.

maps fornece cópia, exclusão e igualdade para map[K]V.

cmp define Ordered, Compare e Or para construir restrições e comparadores.

Algoritmos customizados seguem os mesmos padrões: um parâmetro de tipo para elementos, parâmetros separados para chaves e valores quando necessário.

Receita

Cartão de referência rápida - pronto para copiar e colar.

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

Quando usar isso:

• Ordenação, busca binária, compactação, inserção, exclusão em slices.
• Clonagem ou mesclagem de mapas sem loops manuais.
• Construção de restrições com cmp.Ordered em vez de copiar grandes uniões.

Exemplo de Trabalho

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

O que isso demonstra:

• slices.Sort requer elementos ordenados; SortFunc aceita comparadores customizados que retornam o sinal cmp.
• maps.Clone e maps.Equal evitam cópia/igualdade feitas manualmente.
• A ordenação de structs usa cmp.Compare nos campos, não == nas structs, a menos que sejam totalmente comparáveis e essa seja a ordem pretendida.

Mergulho Profundo

Como Funciona

• As funções genéricas da biblioteca padrão são implementadas uma vez na biblioteca e monomorfizadas nos seus pontos de chamada.
• As funções slices modificam as slices no local, a menos que o nome diga Clone ou retorne uma nova slice.
• As funções maps não copiam valores profundamente; ponteiros e slices dentro dos valores são alias como atribuição de mapa comum.
• cmp.Compare retorna -1, 0 ou 1 para tipos ordenados e é o tipo de retorno preferido do comparador para slices.SortFunc.

Destaques de slices

Destaques de maps

Destaques de cmp

Notas do Go

// Ordenação de múltiplas chaves com 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),
    )
})

• Prefira slices.SortFunc em vez de sort.Slice para código novo - assinaturas de comparador mais claras.
• Para requisitos de ordenação estável, verifique se slices.SortStableFunc se encaixa na sua versão do Go e use-a quando elementos iguais devem manter a ordem de entrada.
• Transformações genéricas customizadas de Map ainda são úteis: func Map[T, U any](in []T, f func(T) U) []U.

Armadilhas

• Ordenação com == em structs - Use SortFunc com ordem explícita de campos. Correção: cmp.Or nos campos.
• Assumir que maps.Clone copia profundamente - Valores são alias. Correção: clone estruturas aninhadas explicitamente quando necessário.
• Busca binária em slice não ordenada - Resultados de posição indefinidos. Correção: ordene primeiro ou documente o pré-requisito.
• Reutilizar uniões de restrições localmente - Desvio da biblioteca padrão. Correção: importe cmp.Ordered.
• Modificar slice durante iteração em algoritmo customizado - Pula elementos ou causa race conditions. Correção: loops baseados em índice ou colete os índices primeiro.
• Passar mapa nil para maps.Copy - Pânico ao escrever em mapa nil. Correção: dst = make(map[K]V) antes da cópia.

Alternativas

FAQs

Relacionados

• Noções Básicas de Genéricos - Introdução a slices.Contains
• Parâmetros de Tipo e Interfaces de Restrição - Definição de cmp.Ordered
• Conjuntos de Tipos e a Restrição comparable - maps.Equal vs ==
• Estruturas de Dados Genéricas: Conjuntos, Filas, Mapas - contêineres que usam esses helpers
• Implicações de Desempenho dos Genéricos - custo de ordenação e inlining

Versões da Pilha: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última - verifique na compilação), gin (última - verifique na compilação), echo (última - verifique na compilação), google.golang.org/grpc (última - verifique na compilação), sigs.k8s.io/controller-runtime (última - verifique na compilação), kubebuilder (última - verifique na compilação), tinygo (última - verifique os alvos da placa na compilação), wazero (última - verifique na compilação) e golangci-lint (última - verifique o conjunto de linters na compilação).