Go Academy · Aula

A interface Stringer

Personalize como os tipos são impressos

A interface Stringer é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 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.

Impressão padrão de estruturas

Por padrão, imprimir uma estrutura com %v mostra seus campos brutos. Isso é adequado para depuração, mas nem sempre é fácil de ler.

package main

import "fmt"

type Color struct{ R, G, B int }

func main() {
    c := Color{255, 0, 0}
    fmt.Println(c)
}

A interface Stringer

A interface fmt.Stringer tem um método:

String() string

Qualquer tipo que o defina controla como aparece quando é impresso.

package main

import "fmt"

type Greeting struct{ Name string }

func (g Greeting) String() string {
    return "Hello, " + g.Name
}

func main() {
    fmt.Println(Greeting{"Ada"})
}

Usado automaticamente

Quando um tipo tem um método String(), Println, Printf com %v ou %s e funções semelhantes o chamam automaticamente.

package main

import "fmt"

type Greeting struct{ Name string }

func (g Greeting) String() string {
    return "Hi " + g.Name
}

func main() {
    g := Greeting{"Bob"}
    fmt.Printf("%s and %v\n", g, g)
}

Formatando dentro de String()

Construa o resultado com fmt.Sprintf para produzir uma representação limpa e personalizada.

package main

import "fmt"

type Color struct{ R, G, B int }

func (c Color) String() string {
    return fmt.Sprintf("rgb(%d, %d, %d)", c.R, c.G, c.B)
}

func main() {
    fmt.Println(Color{255, 128, 0})
}

Stringer em tipos nomeados

Stringer não serve apenas para estruturas. Qualquer tipo nomeado, mesmo um baseado em int, pode implementá-lo. Esse é o padrão clássico de enumeração.

package main

import "fmt"

type Day int

func (d Day) String() string {
    names := []string{"Mon", "Tue", "Wed"}
    return names[d]
}

func main() {
    fmt.Println(Day(1))
}

Enumerações com impressão legível

Combine iota com Stringer para que as constantes sejam impressas como nomes legíveis, em vez de números.

package main

import "fmt"

type State int

const (
    Idle State = iota
    Running
    Done
)

func (s State) String() string {
    return []string{"Idle", "Running", "Done"}[s]
}

func main() {
    fmt.Println(Running)
}

Receptor de valor versus receptor de ponteiro

Se String() usar um receptor de valor, tanto os valores quanto os ponteiros serão impressos corretamente. Com um receptor de ponteiro, apenas os ponteiros o acionam.

package main

import "fmt"

type Tag struct{ Name string }

func (t Tag) String() string { return "#" + t.Name }

func main() {
    t := Tag{"go"}
    fmt.Println(t)
    fmt.Println(&t)
}

Evitando recursão infinita

Nunca chame fmt.Sprintf("%v", t) no mesmo tipo dentro do próprio String(). Isso chama String() novamente sem parar. Formate os campos diretamente.

package main

import "fmt"

type Money struct{ Cents int }

func (m Money) String() string {
    return fmt.Sprintf("$%.2f", float64(m.Cents)/100)
}

func main() {
    fmt.Println(Money{1050})
}

Stringer em fatias

Quando você imprime uma fatia de valores Stringer, cada elemento é formatado com seu método String().

package main

import "fmt"

type Tag struct{ Name string }

func (t Tag) String() string { return "#" + t.Name }

func main() {
    tags := []Tag{{"go"}, {"web"}}
    fmt.Println(tags)
}

Usando-o como uma interface

Você pode armazenar qualquer valor Stringer em uma variável fmt.Stringer e chamar String() por meio da interface.

package main

import "fmt"

type City struct{ Name string }

func (c City) String() string { return "City of " + c.Name }

func main() {
    var s fmt.Stringer = City{"Oslo"}
    fmt.Println(s.String())
}

Por que isso é importante

Implementar Stringer fornece uma saída limpa para seus tipos em todos os lugares onde eles são impressos ou registrados, sem código extra de formatação em cada local de chamada.

package main

import "fmt"

type Temp float64

func (t Temp) String() string {
    return fmt.Sprintf("%.1f°C", float64(t))
}

func main() {
    fmt.Println(Temp(21.5))
}

Verificação rápida

Qual método um tipo precisa definir para satisfazer fmt.Stringer?

Recapitulação: a interface Stringer

Você aprendeu a personalizar a impressão:

Implemente String() string para satisfazer fmt.Stringer.
fmt o chama automaticamente para %v e %s.
É excelente para enumerações; evite usar %v recursivamente no mesmo tipo.

package main

import "fmt"

type Level int

func (l Level) String() string {
    return []string{"low", "mid", "high"}[l]
}

func main() {
    fmt.Println(Level(2))
}

Perguntas Frequentes

A aula “A interface Stringer” é grátis?

Sim — o texto completo de “A interface Stringer” é 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 “A interface Stringer”?

Personalize como os tipos são impressos 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 3 de 4.

Quanto tempo leva a aula “A interface Stringer”?

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