Structs, Embedding e Promoção de Campos

Structs agrupam campos nomeados em um único tipo.

Embedding permite compor comportamento e campos de outros tipos sem herança, promovendo membros exportados para o tipo externo.

Resumo

Uma literal de struct define campos por nome ou posição (se não ambíguo).

Campos incorporados devem ser sem nome e o nome do tipo se torna um nome de campo para promoção.

Campos e métodos promovidos são chamáveis no valor externo como se declarados ali, a menos que sejam ocultados.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

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

Quando usar isso:

• Modelar registros com campos nomeados (User, Order, Config).
• Compor pequenas capacidades via embedding (io.Reader, sync.Mutex).
• Expor API promovida apenas quando o tipo externo realmente é um uso do tipo incorporado.
• Preferir campos explícitos quando os nomes colidirem ou confundirem os leitores.

Exemplo de Trabalho

package main
 
import "fmt"
 
type Person struct {
    Name string
    Age  int
}
 
type Employee struct {
    Person
    ID     int
    Dept   string
}
 
func (p Person) Greet() string {
    return "hello, " + p.Name
}
 
func describe(e Employee) {
    fmt.Println(e.Name, e.ID, e.Greet())
}
 
func main() {
    e := Employee{
        Person: Person{Name: "Ada", Age: 36},
        ID:     1001,
        Dept:   "research",
    }
    describe(e)
 
    // Campo externo explícito vence sobre o promovido se os nomes colidirem
    type Shadow struct {
        Person
        Name string
    }
    sh := Shadow{Person: Person{Name: "Grace"}, Name: "Override"}
    fmt.Println(sh.Name, sh.Person.Name)
}

O que isso demonstra:

• Inicialização aninhada com literais de struct nomeados.
• Promoção de método de Person incorporado para Employee.
• Promoção de campo: e.Name acessa Person.Name incorporado.
• Campos externos ocultam nomes promovidos - use acesso qualificado quando ambos existirem.

Mergulho Profundo

Como Funciona

• Tipos de struct são comparáveis quando todos os campos são comparáveis.
• Embedding é açúcar sintático: os campos e métodos exportados do tipo incorporado promovem um nível.
• Métodos se anexam ao conjunto de métodos do tipo incorporado; o tipo externo ganha esses métodos em seu conjunto de métodos.
• Receptores de ponteiro em tipos incorporados ainda promovem para valores externos endereçáveis.

Formas de Literais de Struct

Regras de Promoção

Notas Go

// Incorpora interface para encaminhar comportamento
type ReadCloser struct {
    io.Reader
    io.Closer
}
 
// Incorpora mutex - valor zero utilizável
type SafeMap struct {
    sync.Mutex
    m map[string]int
}

Armadilhas

• Embedding apenas para composição - APIs promovidas vazam a superfície do tipo incorporado inesperadamente. Correção: incorpore structs auxiliares não exportadas ou delegue explicitamente.
• Ponteiro incorporado nulo - *T incorporado com nil causa pânico na chamada de método promovido. Correção: garanta a inicialização ou proteja as chamadas.
• Tags JSON em campos incorporados - Campos anônimos são achatados em encoding/json por padrão. Correção: nomeie campos ou ajuste tags quando a aninhamento for importante.
• Struct comparável com campo de slice - A struct se torna não comparável. Correção: não use ==; compare os campos manualmente.
• Confusão de campo oculto - Leitores podem não saber qual Name se aplica. Correção: evite nomes de campo duplicados entre tipos externos e incorporados.
• Incorporar tipo concreto para "herança" - Go não tem polimorfismo de subclasse apenas por embedding. Correção: use interfaces para contratos de comportamento.

Alternativas

FAQs

Relacionado

• Ponteiros e o Operador Endereço-de - Receptores de ponteiro e mutação de struct
• Valores Zero e Inicialização - Literais de struct e padrões
• Arrays, Slices e Maps em Resumo - Campos que contêm coleções
• Noções Básicas de Fundamentos Go - Exemplo rápido de embedding

Links Externos Relacionados

• Effective Go - Guia oficial para escrever Go claro e idiomático.
• Go Language Specification - A referência formal da linguagem.
• Go by Example - Exemplos de código práticos anotados.
• The Go Programming Language (Paperback) - Livro de Donovan & Kernighan.
• Learning Go (2nd Edition) - Jon Bodner.

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, modernizadores go fix - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).

636f64656775696465732e696f7c6367696f3439377c323032363037