Go Academy · Lección

Structs anónimos y composición

Incrustación y reutilización de código basada en structs

Structs anónimos y composición es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 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.

Structs anónimos

Un struct anónimo no tiene un tipo con nombre. Se define directamente en el lugar donde se usa y resulta útil para datos de corta duración, pruebas basadas en tablas y agrupaciones puntuales:

package main
import "fmt"

func main() {
    point := struct{ X, Y int }{X: 3, Y: 7}
    fmt.Println(point.X, point.Y)
}

Structs anónimos en pruebas basadas en tablas

Un modismo habitual de Go consiste en usar un slice de structs anónimos para realizar pruebas basadas en tablas:

package main
import "fmt"

func double(n int) int { return n * 2 }

func main() {
    tests := []struct{ input, want int }{
        {1, 2}, {5, 10}, {0, 0},
    }
    for _, tt := range tests {
        got := double(tt.input)
        if got != tt.want {
            fmt.Printf("FAIL: double(%d) = %d, want %d\n", tt.input, got, tt.want)
        }
    }
    fmt.Println("all tests passed")
}

Embedding de structs

Incluir un tipo dentro de un struct promueve sus campos y métodos al struct externo:

package main
import "fmt"

type Animal struct{ Name string }
func (a Animal) Speak() string { return a.Name + " speaks" }

type Dog struct {
    Animal        // embedded
    Breed string
}

func main() {
    d := Dog{Animal: Animal{"Rex"}, Breed: "Labrador"}
    fmt.Println(d.Name)    // promoted field
    fmt.Println(d.Speak()) // promoted method
}

Embedding múltiple

Un struct puede incluir varios tipos. Los conflictos (el mismo nombre de campo o método) deben resolverse explícitamente:

package main
import "fmt"

type Logger struct{}
func (Logger) Log(s string) { fmt.Println("[LOG]", s) }

type Metrics struct{}
func (Metrics) Count() int { return 42 }

type Service struct {
    Logger
    Metrics
    Name string
}

func main() {
    svc := Service{Name: "auth"}
    svc.Log("started")       // from Logger
    fmt.Println(svc.Count()) // from Metrics
}

Embedding frente a herencia

Go no tiene herencia de clases. El embedding es composición:

El embedding promueve campos y métodos, pero el tipo externo no es un subtipo
No puede pasar un Dog donde se espera un Animal
Use interfaces para el polimorfismo y embedding para reutilizar código

Redefinir métodos promovidos

El struct externo puede ocultar un método incluido si define uno propio:

package main
import "fmt"

type Base struct{}
func (Base) Hello() string { return "Base hello" }

type Child struct{ Base }
func (Child) Hello() string { return "Child hello" } // shadows Base.Hello

func main() {
    c := Child{}
    fmt.Println(c.Hello())      // Child hello
    fmt.Println(c.Base.Hello()) // Base hello (explicit)
}

Struct anónimo para configuración

Use un struct anónimo para agrupar configuraciones relacionadas sin definir un tipo con nombre:

package main
import "fmt"

func main() {
    cfg := struct {
        Host string
        Port int
        TLS  bool
    }{
        Host: "api.example.com",
        Port: 443,
        TLS:  true,
    }
    fmt.Println(cfg)
}

Embedding de una interfaz

Incluir una interfaz en un struct resulta útil para crear mocks e implementaciones predeterminadas:

package main
import "fmt"

type Reader interface{ Read() string }

type Mock struct{ Reader }  // embed interface

func main() {
    m := Mock{}
    fmt.Printf("%T\n", m.Reader) // <nil> — not set
    // Assign a real impl at test time:
    _ = m
}

Problemas de la composición de structs

Preste atención a lo siguiente:

Selectores ambiguos cuando dos tipos incluidos tienen el mismo nombre de campo o método
Un puntero incluido nil puede provocar un panic al llamar a sus métodos
No olvide que el embedding no es herencia: no puede sustituir el tipo externo por el tipo incluido

Comparación de structs anónimos

Dos structs anónimos con los mismos nombres y tipos de campo se pueden asignar entre sí si sus etiquetas también coinciden:

package main
import "fmt"

func main() {
    a := struct{ X, Y int }{1, 2}
    b := struct{ X, Y int }{1, 2}
    fmt.Println(a == b) // true
}

Comprobación rápida

¿Qué se consigue al incluir un tipo en un struct?

Recapitulación: composición

Conclusiones principales:

Los structs anónimos son ideales para pruebas basadas en tablas y datos de corta duración
El embedding promueve campos y métodos; es composición, no herencia
Los tipos externos pueden ocultar métodos incluidos
Resuelva explícitamente los selectores ambiguos
Use interfaces para el polimorfismo

Ejercicio práctico

Cree un struct TimestampedRecord que incluya un Timestamp struct{ CreatedAt, UpdatedAt string } y un Data struct{ Key, Value string }. Instáncielo y muestre todos los campos promovidos.

Preguntas frecuentes

¿La lección «Structs anónimos y composición» es gratis?

Sí — el texto completo de «Structs anónimos y composición» 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 «Structs anónimos y composición»?

Incrustación y reutilización de código basada en structs 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 4 de 4.

¿Cuánto tiempo toma la lección «Structs anónimos y composición»?

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