Go Academy · Lección

Estructuras de datos genéricas

Creación de un Stack y un Set genéricos

Estructuras de datos genéricas es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Por qué utilizar estructuras de datos genéricas?

Antes de los genéricos, los desarrolladores de Go utilizaban slices de interface{} (perdiendo la seguridad de tipos) o generaban código para cada tipo. Los genéricos permiten crear contenedores reutilizables con seguridad de tipos.

Pila genérica

Una pila con seguridad de tipos que utiliza un 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) }

Cola genérica

Una cola FIFO respaldada por un slice:

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

Un conjunto respaldado por un mapa; el tipo de clave debe ser comparable:

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

Helper genérico Map

Un Map funcional y con seguridad de tipos para slices:

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

Devuelve un slice nuevo que contiene únicamente los elementos que cumplen un 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

Reduce un slice a un ú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

Un mapa ordenado que conserva el orden de inserción; resulta útil para serializar JSON con un orden estable de las claves:

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

Lista enlazada genérica

Una lista doblemente enlazada con elementos con seguridad de tipos:

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

Limitaciones

Los tipos genéricos no pueden utilizar type switches sobre T. Los métodos de tipos genéricos no pueden introducir nuevos parámetros de tipo. No se puede especializar un tipo genérico para un T específico (no existe especialización de plantillas).

Rendimiento

La instanciación genérica en Go se realiza mediante "GC shapes": los tipos con la misma disposición de memoria comparten una implementación. Esto evita la expansión excesiva del código y mantiene un rendimiento cercano al de las implementaciones concretas.

Cuándo no utilizar genéricos

Evite los genéricos en casos sencillos en los que una interfaz sea suficiente o cuando solo tenga uno o dos tipos concretos; la complejidad añadida no compensa el beneficio.

Comprobación rápida

¿Por qué un Set genérico requiere la restricción comparable en su parámetro de tipo?

Resumen: estructuras de datos genéricas

Puntos clave:

Stack, Queue y Set: seguridad de tipos gracias a los genéricos
Helpers funcionales: Map, Filter y Reduce sobre []T
Set[T comparable] para conjuntos respaldados por mapas
No hay parámetros de tipo a nivel de método ni especialización de plantillas

Preguntas frecuentes

¿La lección «Estructuras de datos genéricas» es gratis?

Sí — el texto completo de «Estructuras de datos genéricas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Estructuras de datos genéricas»?

Creación de un Stack y un Set genéricos Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Estructuras de datos genéricas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy