Go Academy · Aula

Definindo e usando structs

Literais de struct, acesso a campos e embedding

Definindo e usando structs é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.

O que é uma estrutura?

Uma estrutura agrupa campos relacionados de tipos diferentes sob um único tipo nomeado. É o principal mecanismo do Go para definir estruturas de dados personalizadas — semelhante a uma classe, mas sem herança.

Declaração de uma estrutura

Defina um tipo de estrutura com a palavra-chave type:

package main
import "fmt"

type Person struct {
    Name string
    Age  int
    City string
}

func main() {
    p := Person{Name: "Alice", Age: 30, City: "London"}
    fmt.Println(p)
}

Literais de estrutura

Há dois estilos: campos nomeados (preferível) e posicional (dependente da ordem e frágil):

package main

type Point struct{ X, Y int }

func main() {
    p1 := Point{X: 1, Y: 2} // named — preferred
    p2 := Point{3, 4}        // positional — avoid in non-test code
    _ = p1; _ = p2
}

Acessando campos

Use a notação de ponto para ler e gravar campos:

package main
import "fmt"

type Car struct{ Brand string; Speed int }

func main() {
    c := Car{Brand: "Tesla", Speed: 200}
    fmt.Println(c.Brand)  // Tesla
    c.Speed = 250
    fmt.Println(c.Speed)  // 250
}

Valor zero de uma estrutura

O valor zero de uma estrutura define todos os campos com seus respectivos valores zero. Você pode usá-la com segurança sem inicialização:

package main
import "fmt"

type Config struct{ Debug bool; Port int; Host string }

func main() {
    var cfg Config
    fmt.Println(cfg) // {false 0 }
    cfg.Port = 8080
    fmt.Println(cfg) // {false 8080 }
}

Comparação de estruturas

As estruturas podem ser comparadas com == se todos os seus campos puderem ser comparados:

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    a := Point{1, 2}
    b := Point{1, 2}
    c := Point{3, 4}
    fmt.Println(a == b) // true
    fmt.Println(a == c) // false
}

Estruturas são tipos de valor

Atribuir uma estrutura copia todos os seus campos. Alterações na cópia não afetam a original:

package main
import "fmt"

type Rect struct{ W, H int }

func main() {
    r1 := Rect{10, 20}
    r2 := r1
    r2.W = 99
    fmt.Println(r1) // {10 20}
    fmt.Println(r2) // {99 20}
}

Estruturas aninhadas

Um campo de estrutura pode ser, por sua vez, uma estrutura:

package main
import "fmt"

type Address struct{ City, Country string }
type Employee struct {
    Name    string
    Age     int
    Address Address
}

func main() {
    e := Employee{Name: "Bob", Age: 28, Address: Address{"Berlin", "DE"}}
    fmt.Println(e.Address.City) // Berlin
}

Campos exportados e não exportados

Campos que começam com uma letra maiúscula são exportados (públicos). Campos em minúsculas são não exportados (privados do pacote):

package main

type config struct {
    host string // unexported
    Port int    // exported
}

func main() {
    c := config{host: "localhost", Port: 8080}
    _ = c
}

Anotações de estrutura

As anotações de estrutura fornecem metadados (por exemplo, para codificação JSON). Elas são literais de cadeia de caracteres após o tipo do campo:

package main

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
}

func main() { _ = User{} }

Verificação rápida

Qual é o valor zero de um campo bool em uma estrutura?

Recapitulação: estruturas

Principais aprendizados:

As estruturas agrupam campos relacionados em um tipo nomeado
Use literais com campos nomeados — evite os posicionais
Estruturas são tipos de valor — a atribuição faz uma cópia
Campos que começam com letras maiúsculas são exportados
Anotações de estrutura adicionam metadados para bibliotecas como a de codificação JSON

Exercício prático

Defina uma estrutura Product com os campos Name string, Price float64 e InStock bool. Crie duas instâncias, compare-as com == e imprima o resultado.

Perguntas Frequentes

A aula “Definindo e usando structs” é grátis?

Sim — o texto completo de “Definindo e usando structs” é 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 “Definindo e usando structs”?

Literais de struct, acesso a campos e embedding 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 1 de 4.

Quanto tempo leva a aula “Definindo e usando structs”?

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