0Pricing
Go Academy · Aula

Genéricos na prática: armadilhas

Saiba quando usar genéricos e conheça erros comuns

Genéricos na prática: armadilhas é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Generalização excessiva

Nem toda função precisa ser genérica. Se apenas um tipo concreto for usado, um genérico adicionará complexidade sem benefício. Prefira tipos concretos e refatore para usar genéricos quando surgir duplicação.

Asserção de tipo dentro de genéricos

Não é possível fazer uma asserção de tipo ou uma seleção de tipo dentro de uma função genérica usando o próprio parâmetro de tipo — os genéricos não são modelos. Em vez disso, use interfaces ou o pacote reflect.

// WRONG:
func Foo[T any](v T) {
    if x, ok := v.(int); ok { // compile error
    }
}

Comparable não significa Ordered

comparable oferece suporte apenas a ==. Para usar < e >, é necessário usar cmp.Ordered ou uma restrição personalizada. Um erro comum é presumir que comparable abrange a ordenação.

Um método não pode introduzir parâmetros de tipo

Os métodos de tipos genéricos reutilizam os parâmetros do tipo, mas não podem adicionar novos parâmetros. Se um método precisar de um parâmetro de tipo adicional, use uma função de nível superior.

// WRONG:
func (s *Stack[T]) MapTo[U any]() []U // compile error

Valores nil e zero

Para parâmetros de tipo ponteiro, o valor zero é nil. Para tipos de valor, ele é o zero do tipo. Sempre trate o caso zero em vez de presumir que o valor não é nil.

Conjuntos de métodos de interfaces e genéricos

Uma função genérica restrita a uma interface só pode chamar os métodos declarados nessa interface. Adicionar métodos a um tipo concreto não os torna disponíveis por meio da restrição.

Aumento de instanciações (formas de GC)

O Go compartilha implementações para tipos com a mesma forma de GC (por exemplo, todos os tipos ponteiro compartilham uma implementação). Os tipos primitivos recebem cada um a sua própria implementação, mas a abordagem do Go mantém os tamanhos dos binários razoáveis.

Any não é interface{}

any é um alias para interface{}, mas uma função genérica F[T any] não é igual a F(v interface{}) — no caso genérico, T é o tipo concreto no local da chamada, preservando as informações de tipo.

Tipos genéricos recursivos

O Go não oferece suporte a definições recursivas de parâmetros de tipo, como type Tree[T Tree[T]]. Em vez disso, use composição:

type TreeNode[T any] struct {
    Val   T
    Left  *TreeNode[T]
    Right *TreeNode[T]
}

Auxiliares pré-instanciados

Para códigos sensíveis ao desempenho, pré-instancie funções genéricas usadas com frequência como funções de nível superior para evitar o custo repetido da inferência de tipos (embora o compilador Go lide bem com isso).

Testando código genérico

Teste funções genéricas com várias instanciações: uma para cada restrição distinta (int, string, um tipo personalizado). Isso identifica casos extremos específicos das restrições.

func TestMap(t *testing.T) {
    got := Map([]int{1,2}, double)
    // test with strings too
    gotS := Map([]string{"a","b"}, strings.ToUpper)
}

Verificação rápida

Por que não é possível fazer uma seleção de tipo sobre um parâmetro de tipo genérico T dentro de uma função genérica?

Recapitulação: armadilhas dos genéricos

Pontos principais:

  • Não generalize excessivamente; tipos concretos são mais simples quando usados uma única vez
  • Nenhuma seleção ou asserção de tipo sobre T dentro de funções genéricas
  • comparable não significa ordenado; use cmp.Ordered para oferecer suporte a <
  • Os métodos não podem introduzir novos parâmetros de tipo

Perguntas Frequentes

A aula “Genéricos na prática: armadilhas” é grátis?

Sim — o texto completo de “Genéricos na prática: armadilhas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Genéricos na prática: armadilhas”?

Saiba quando usar genéricos e conheça erros comuns Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Genéricos na prática: armadilhas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Sintaxe de parâmetros de tipo
  2. Restrições: comparable e interfaces
  3. Estruturas de dados genéricas
  4. Genéricos na prática: armadilhas
← Voltar para Go Academy