Métodos em structs
Receptores de valor versus receptores de ponteiro
Métodos em structs é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 2 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 é um método?
Um método é uma função com um argumento receptor. O receptor aparece entre a palavra-chave func e o nome do método, vinculando a função a um tipo.
Receptor por valor
Um receptor por valor recebe uma cópia da estrutura. Use-o quando o método não precisar modificar o estado:
package main
import "fmt"
type Circle struct{ Radius float64 }
func (c Circle) Area() float64 {
return 3.14159 * c.Radius * c.Radius
}
func main() {
c := Circle{Radius: 5}
fmt.Printf("%.2f\n", c.Area()) // 78.54
}Receptor por ponteiro
Um receptor por ponteiro permite que o método modifique a estrutura. É mais eficiente para estruturas grandes:
package main
import "fmt"
type Counter struct{ N int }
func (c *Counter) Increment() { c.N++ }
func (c *Counter) Reset() { c.N = 0 }
func main() {
c := Counter{}
c.Increment(); c.Increment()
fmt.Println(c.N) // 2
c.Reset()
fmt.Println(c.N) // 0
}Quando usar receptores por ponteiro
Use receptores por ponteiro quando:
- O método precisar modificar o receptor
- A estrutura for grande (evita cópias)
- Houver consistência: se algum método tiver um receptor por ponteiro, todos deverão ter
Use receptores por valor quando a estrutura for pequena e o método apenas ler os dados.
Expressões e valores de métodos
Os métodos podem ser usados como valores de primeira classe:
package main
import "fmt"
type Adder struct{ Base int }
func (a Adder) Add(n int) int { return a.Base + n }
func main() {
a := Adder{Base: 10}
fn := a.Add // method value — bound to a
fmt.Println(fn(5)) // 15
}Métodos em tipos que não são estruturas
Você pode definir métodos em qualquer tipo nomeado do mesmo pacote, não apenas em estruturas:
package main
import "fmt"
type Celsius float64
func (c Celsius) ToFahrenheit() float64 {
return float64(c)*9/5 + 32
}
func main() {
t := Celsius(100)
fmt.Println(t.ToFahrenheit()) // 212
}Desreferenciação automática de ponteiros
Go obtém automaticamente o endereço ou faz a desreferenciação ao chamar métodos. Você não precisa escrever (&c).Method() manualmente:
package main
import "fmt"
type Box struct{ Val int }
func (b *Box) Double() { b.Val *= 2 }
func main() {
b := Box{Val: 5}
b.Double() // Go auto-takes address
fmt.Println(b.Val) // 10
}Encadeando métodos
Retorne o ponteiro do receptor para permitir o encadeamento de métodos (padrão de construção):
package main
import "fmt"
type Builder struct{ result string }
func (b *Builder) Add(s string) *Builder {
b.result += s
return b
}
func (b *Builder) Build() string { return b.result }
func main() {
s := (&Builder{}).Add("Hello").Add(", ").Add("World").Build()
fmt.Println(s)
}Método de cadeia de caracteres (fmt.Stringer)
Implemente o método String() string para controlar como um tipo é impresso:
package main
import "fmt"
type Point struct{ X, Y int }
func (p Point) String() string {
return fmt.Sprintf("(%d, %d)", p.X, p.Y)
}
func main() {
p := Point{3, 4}
fmt.Println(p) // (3, 4)
}Receptores de ponteiro nulo
Um método com receptor por ponteiro pode ser chamado em um ponteiro nulo — isso é útil para comportamentos padrão:
package main
import "fmt"
type Node struct{ Val int }
func (n *Node) Value() int {
if n == nil { return 0 }
return n.Val
}
func main() {
var n *Node
fmt.Println(n.Value()) // 0
}Princípio da consistência
Na biblioteca padrão do Go e no Go idiomático, todos os métodos de um tipo usam o mesmo tipo de receptor — todos por ponteiro ou todos por valor. Misturá-los causa erros sutis com interfaces.
Verificação rápida
Qual tipo de receptor permite que um método modifique os campos da estrutura?
Recapitulação: métodos
Principais aprendizados:
- Os métodos têm um receptor entre
funce o nome - Receptores por valor: somente leitura, estruturas pequenas
- Receptores por ponteiro: modificação, estruturas grandes, consistência
- Go faz a desreferenciação automaticamente — não é necessário escrever
(&v).Method() - Implemente
String() stringpara obter uma impressão personalizada
Exercício prático
Defina uma estrutura BankAccount com um campo Balance float64. Adicione os métodos de receptor por ponteiro Deposit e Withdraw e um método de receptor por valor String().
Perguntas Frequentes
A aula “Métodos em structs” é grátis?
Sim — o texto completo de “Métodos em 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 “Métodos em structs”?
Receptores de valor versus receptores de ponteiro 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 2 de 4.
Quanto tempo leva a aula “Métodos em 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.