Go Academy · Aula

Sintaxe de parâmetros de tipo

Crie funções e tipos genéricos com [T any]

Sintaxe de parâmetros de tipo é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.

Contexto dos genéricos

Antes do Go 1.18, o código que funcionava com vários tipos exigia interface{}/any (com perda de segurança de tipos) ou geração de código. Os genéricos acrescentam parâmetros de tipo para o polimorfismo em tempo de compilação.

Sintaxe de função genérica

Declare os parâmetros de tipo entre colchetes após o nome da função:

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

nums := Map([]int{1,2,3}, func(n int) string {
    return strconv.Itoa(n)
})

Inferência de tipos

Na maioria dos casos, o compilador infere os argumentos de tipo a partir dos argumentos da função. Você pode especificá-los explicitamente se a inferência falhar.

// Inferred:
nums := Map([]int{1,2,3}, strconv.Itoa)
// Explicit:
nums := Map[int, string]([]int{1,2,3}, strconv.Itoa)

Tipos genéricos

As estruturas e outros tipos também podem ter parâmetros de tipo:

type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 { var zero T; return zero, false }
    n := len(s.items)-1
    v := s.items[n]
    s.items = s.items[:n]
    return v, true
}

Vários parâmetros de tipo

As funções e os tipos podem ter vários parâmetros de tipo:

type Pair[K, V any] struct { Key K; Value V }

func Zip[K, V any](keys []K, vals []V) []Pair[K, V] {
    result := make([]Pair[K, V], min(len(keys), len(vals)))
    for i := range result {
        result[i] = Pair[K, V]{keys[i], vals[i]}
    }
    return result
}

Valor zero do parâmetro de tipo

Declare uma variável com o valor zero usando var zero T. Isso é necessário ao retornar um resultado de "nenhum valor" de uma função genérica.

func First[T any](s []T) (T, bool) {
    if len(s) == 0 { var zero T; return zero, false }
    return s[0], true
}

Métodos em tipos genéricos

Os métodos de um tipo genérico utilizam os parâmetros do tipo, não parâmetros próprios. Um método não pode introduzir parâmetros de tipo adicionais.

type Pair[K, V any] struct{ K K; V V }
func (p Pair[K, V]) Swap() Pair[V, K] { return Pair[V, K]{p.V, p.K} }

Instanciação

Utilizar um tipo genérico com um argumento de tipo concreto é chamado de instanciação. Isso ocorre em tempo de compilação, não em tempo de execução — não há sobrecarga de encaixotamento.

s := Stack[int]{}
s.Push(42)

Aliases de tipo e tipos genéricos

Você pode criar aliases de tipo para tipos genéricos instanciados:

type IntStack = Stack[int]

Limitações

Os parâmetros de tipo não podem ser utilizados com alternâncias de tipo nem com asserções de tipo. Os métodos de tipos genéricos não podem ter parâmetros de tipo adicionais. Os genéricos não podem ser utilizados em tipos com operadores sobrecarregados sem restrições.

Quando utilizar genéricos

Utilize genéricos para algoritmos realmente independentes de tipo (tipos de contêiner, auxiliares funcionais como Map/Filter/Reduce) quando a alternativa seria duplicar código ou fazer conversões de tipo inseguras.

Verificação rápida

Onde os parâmetros de tipo são declarados em uma função genérica?

Recapitulação: sintaxe dos parâmetros de tipo

Pontos principais:

Parâmetros de tipo entre colchetes: func Foo[T any](...)
Funciona com funções e tipos (estruturas etc.)
Na maioria dos casos, o compilador infere os argumentos de tipo a partir dos argumentos
Valor zero: var zero T; não há parâmetros de tipo no nível do método

Perguntas Frequentes

A aula “Sintaxe de parâmetros de tipo” é grátis?

Sim — o texto completo de “Sintaxe de parâmetros de tipo” é 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 “Sintaxe de parâmetros de tipo”?

Crie funções e tipos genéricos com [T any] 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 1 de 4.

Quanto tempo leva a aula “Sintaxe de parâmetros de tipo”?

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

← Voltar para Go Academy