Go Academy · Aula

Estruturas de dados genéricas

Crie uma Stack e um Set genéricos

Estruturas de dados genéricas é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 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.

Por que usar estruturas de dados genéricas?

Antes dos genéricos, os desenvolvedores Go usavam fatias de interface{} (perdendo a segurança de tipos) ou geravam código para cada tipo. Os genéricos permitem criar contêineres reutilizáveis e seguros quanto aos tipos.

Pilha genérica

Uma pilha segura quanto aos tipos usando um tipo genérico:

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 z T; return z, false }
    n := len(s.items)-1; v := s.items[n]; s.items = s.items[:n]; return v, true
}
func (s *Stack[T]) Len() int { return len(s.items) }

Fila genérica

Uma fila FIFO implementada com uma fatia:

type Queue[T any] struct{ items []T }
func (q *Queue[T]) Enqueue(v T)     { q.items = append(q.items, v) }
func (q *Queue[T]) Dequeue() (T, bool) {
    if len(q.items)==0 { var z T; return z, false }
    v := q.items[0]; q.items = q.items[1:]; return v, true
}

Conjunto genérico

Um conjunto implementado com um mapa — o tipo da chave deve ser comparável:

type Set[T comparable] struct{ m map[T]struct{} }
func NewSet[T comparable]() *Set[T] { return &Set[T]{m: make(map[T]struct{})} }
func (s *Set[T]) Add(v T)          { s.m[v] = struct{}{} }
func (s *Set[T]) Has(v T) bool     { _, ok := s.m[v]; return ok }
func (s *Set[T]) Delete(v T)       { delete(s.m, v) }

Auxiliar Map genérico

Um Map funcional e seguro quanto aos tipos sobre fatias:

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

Filter genérico

Retorne uma nova fatia contendo apenas os elementos que satisfazem um predicado:

func Filter[T any](s []T, predicate func(T) bool) []T {
    var out []T
    for _, v := range s {
        if predicate(v) { out = append(out, v) }
    }
    return out
}

Reduce genérico

Reduza uma fatia a um único valor:

func Reduce[T, U any](s []T, init U, f func(U, T) U) U {
    acc := init
    for _, v := range s { acc = f(acc, v) }
    return acc
}

OrderedMap

Um mapa ordenado que preserva a ordem de inserção — útil para serialização JSON com uma ordem estável das chaves:

type OrderedMap[K comparable, V any] struct {
    keys []K
    vals map[K]V
}

Lista encadeada genérica

Uma lista duplamente encadeada com elementos seguros quanto aos tipos:

type Node[T any] struct{ Val T; Next, Prev *Node[T] }
type List[T any] struct{ head, tail *Node[T]; len int }

Limitações

Os tipos genéricos não podem usar asserções de tipo sobre T. Os métodos de tipos genéricos não podem introduzir novos parâmetros de tipo. Não é possível especializar um tipo genérico para um T específico (não há especialização de modelos).

Desempenho

A instanciação de genéricos no Go é feita por meio de "formas de GC" — tipos com o mesmo layout de memória compartilham uma implementação. Isso evita o aumento excessivo do código e mantém um desempenho próximo ao das implementações concretas.

Quando não usar genéricos

Evite genéricos em casos simples nos quais uma interface seja suficiente ou nos quais haja apenas um ou dois tipos concretos — a complexidade adicional não compensa o benefício.

Verificação rápida

Por que um Set genérico exige a restrição comparable em seu parâmetro de tipo?

Recapitulação: estruturas de dados genéricas

Pontos principais:

Stack, Queue, Set — segurança de tipos com genéricos
Auxiliares funcionais: Map, Filter, Reduce sobre []T
Set[T comparable] para conjuntos implementados com mapas
Nenhum parâmetro de tipo em nível de método; nenhuma especialização de modelos

Perguntas Frequentes

A aula “Estruturas de dados genéricas” é grátis?

Sim — o texto completo de “Estruturas de dados genéricas” é 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 “Estruturas de dados genéricas”?

Crie uma Stack e um Set genéricos 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 3 de 4.

Quanto tempo leva a aula “Estruturas de dados genéricas”?

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