Go Academy · Aula

Structs anônimas e composição

Embedding e reutilização de código baseada em structs

Structs anônimas e composição é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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.

Estruturas anônimas

Uma estrutura anônima não tem um tipo nomeado. Ela é definida diretamente e é útil para dados de curta duração, testes orientados por tabela e agrupamentos pontuais:

package main
import "fmt"

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

Estruturas anônimas em testes orientados por tabela

Um uso comum e idiomático em Go é utilizar uma fatia de estruturas anônimas para testes orientados por tabela:

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

Incorporação de estruturas

Incorporar um tipo em uma estrutura promove seus campos e métodos para a estrutura externa:

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
}

Múltiplas incorporações

Uma estrutura pode incorporar vários tipos. Conflitos (mesmo nome de campo ou método) precisam ser resolvidos explicitamente:

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
}

Incorporação versus herança

Go não tem herança de classes. A incorporação é composição:

A incorporação promove campos e métodos, mas o tipo externo não é um subtipo
Você não pode passar um Dog onde se espera um Animal
Use interfaces para polimorfismo e incorporação para reutilização de código

Substituindo métodos promovidos

A estrutura externa pode ocultar um método incorporado definindo o seu próprio:

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

Estrutura anônima para configuração

Use uma estrutura anônima para agrupar configurações relacionadas sem definir um tipo nomeado:

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

Incorporando uma interface

Incorporar uma interface em uma estrutura é útil para simulação e implementações padrão:

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
}

Armadilhas da composição de estruturas

Fique atento a:

Seletores ambíguos quando dois tipos incorporados têm o mesmo nome de campo ou método
Um ponteiro incorporado nulo que causa um pânico quando você chama métodos nele
Esquecer que incorporação não é herança — você não pode substituir o tipo incorporado pelo tipo externo

Comparando estruturas anônimas

Duas estruturas anônimas com os mesmos nomes e tipos de campos podem ser atribuídas uma à outra se suas anotações também coincidirem:

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
}

Verificação rápida

O que incorporar um tipo em uma estrutura proporciona?

Recapitulação: composição

Principais aprendizados:

Estruturas anônimas são excelentes para testes orientados por tabela e dados de curta duração
A incorporação promove campos e métodos — é composição, não herança
Tipos externos podem ocultar métodos incorporados
Resolva seletores ambíguos explicitamente
Use interfaces para polimorfismo

Exercício prático

Crie uma estrutura TimestampedRecord que incorpore uma Timestamp struct{ CreatedAt, UpdatedAt string } e uma Data struct{ Key, Value string }. Instancie-a e imprima todos os campos promovidos.

Perguntas Frequentes

A aula “Structs anônimas e composição” é grátis?

Sim — o texto completo de “Structs anônimas e composição” é 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 “Structs anônimas e composição”?

Embedding e reutilização de código baseada em structs 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 4 de 4.

Quanto tempo leva a aula “Structs anônimas e composição”?

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