Structs, Embedding y Promoción de Campos

Las structs agrupan campos con nombre en un único tipo.

El embedding (incrustación) te permite componer comportamiento y campos de otros tipos sin herencia, promoviendo miembros exportados al tipo externo.

Resumen

Una literal de struct establece campos por nombre o posición (si no es ambigua).

Los campos incrustados deben no tener nombre y el nombre de su tipo se convierte en un nombre de campo para la promoción.

Los campos y métodos promovidos son invocables en el valor externo como si estuvieran declarados allí, a menos que sean ocultados (shadowed).

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

package main
 
import "fmt"
 
type Logger struct{}
 
func (Logger) Log(msg string) { fmt.Println(msg) }
 
type Server struct {
    Logger // Campo incrustado anónimo
    Addr string
}
 
func main() {
    s := Server{Addr: ":8080"}
    s.Log("listening") // método promovido
    fmt.Println(s.Addr)
}

Cuándo usar esto:

• Modelar registros con campos con nombre (User, Order, Config).
• Componer pequeñas capacidades mediante embedding (io.Reader, sync.Mutex).
• Exponer una API promovida solo cuando el tipo externo realmente es un uso del tipo incrustado.
• Preferir campos explícitos cuando los nombres colisionarían o confundirían a los lectores.

Ejemplo Funcional

package main
 
import "fmt"
 
type Person struct {
    Name string
    Age  int
}
 
type Employee struct {
    Person // Campo incrustado anónimo
    ID     int
    Dept   string
}
 
func (p Person) Greet() string {
    return "hello, " + p.Name
}
 
func describe(e Employee) {
    // Los campos y métodos de Person se promueven a Employee
    fmt.Println(e.Name, e.ID, e.Greet())
}
 
func main() {
    e := Employee{
        Person: Person{Name: "Ada", Age: 36}, // Inicialización anidada
        ID:     1001,
        Dept:   "research",
    }
    describe(e)
 
    // El campo externo explícito prevalece sobre el promovido si los nombres colisionan
    type Shadow struct {
        Person // Campo incrustado
        Name string // Campo con el mismo nombre que en Person
    }
    sh := Shadow{Person: Person{Name: "Grace"}, Name: "Override"}
    // sh.Name se refiere al campo Name de Shadow, no al de Person
    fmt.Println(sh.Name, sh.Person.Name)
}

Lo que esto demuestra:

• Inicialización anidada con literales de struct con nombre.
• Promoción de métodos desde Person incrustado a Employee.
• Promoción de campos: e.Name accede a Person.Name incrustado.
• Los campos externos ocultan los nombres promovidos; usa acceso calificado cuando ambos existan.

Análisis Profundo

Cómo Funciona

• Los tipos struct son comparables si todos sus campos son comparables.
• El embedding es azúcar sintáctico: los campos y métodos exportados del tipo incrustado se promueven un nivel.
• Los métodos se adjuntan al conjunto de métodos del tipo incrustado; el tipo externo gana esos métodos en su conjunto de métodos.
• Los receptores de puntero en el tipo incrustado aún se promueven para valores externos direccionables.

Formas de Literales de Struct

Reglas de Promoción

Notas de Go

// Incrustar una interfaz para reenviar comportamiento
type ReadCloser struct {
    io.Reader // Campo incrustado anónimo
    io.Closer // Campo incrustado anónimo
}
 
// Incrustar mutex - el valor cero es utilizable
type SafeMap struct {
    sync.Mutex // Campo incrustado anónimo
    m map[string]int
}

Trampas Comunes

• Embedding solo para composición - Las APIs promovidas exponen inesperadamente la superficie del tipo incrustado. Solución: incrustar structs auxiliares no exportadas o delegar explícitamente.
• Puntero incrustado nulo - *T incrustado con valor nulo causa pánico al llamar a un método promovido. Solución: asegurar la inicialización o proteger las llamadas.
• Etiquetas JSON en campos incrustados - Los campos anónimos se aplanan en encoding/json por defecto. Solución: nombrar los campos o ajustar las etiquetas cuando la anidación importa.
• Struct comparable con campo slice - La struct se vuelve no comparable. Solución: no usar ==; comparar campos manualmente.
• Confusión por campo oculto - Los lectores pueden no saber qué Name se aplica. Solución: evitar nombres de campo duplicados entre tipos externos e incrustados.
• Incrustar tipo concreto para "herencia" - Go no tiene polimorfismo de subclase solo mediante embedding. Solución: usar interfaces para contratos de comportamiento.

Alternativas

Preguntas Frecuentes

Relacionado

• Punteros y el Operador de Dirección - Receptores de puntero y mutación de structs
• Valores Cero e Inicialización - Literales de struct y valores por defecto
• Arrays, Slices y Maps de un Vistazo - Campos que contienen colecciones
• Fundamentos de Go Básicos - Ejemplo rápido de embedding

Enlaces Externos Relacionados

• Effective Go - Guía oficial para escribir Go claro e idiomático.
• Go Language Specification - La referencia formal del lenguaje.
• Go by Example - Ejemplos de código prácticos anotados.
• The Go Programming Language (Paperback) - Edición de tapa blanda de Donovan & Kernighan.
• Learning Go (2nd Edition) - Jon Bodner.

Versiones de Stack: Esta página fue escrita para Go 1.26.x (Green Tea GC por defecto, go fix modernizers - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación), y golangci-lint (última - verificar conjunto de linters en la compilación).

636f64656775696465732e696f7c6367696f3439377c323032363037