Exibindo estruturas em Go: do iniciante ao profissional em 10 minutos

Por que "simplesmente imprimir uma estrutura" em Go não é tão simples assim?

Imagine: você está programando em Go, criou uma bela estrutura User, preencheu-a com dados e quer apenas dar uma olhada no que tem dentro. Você escreve fmt.Println(user) e vê algo como {Alex 25 true}. Informativo? Nem tanto. E se houver 15 campos? E se um deles for uma estrutura aninhada? E se for uma slice de estruturas?

A pergunta "How to print struct variables in console?" no Stack Overflow acumulou milhares de visualizações por um motivo. Todo iniciante (e não só) em Golang se depara com o fato de que a saída padrão de estruturas é uma string sem nomes de campos. E quando o projeto cresce, a depuração vira um jogo de adivinhação.

Neste artigo, vamos abordar todas as formas de exibir estruturas no console Go: das básicas às avançadas. Você aprenderá como exibir uma estrutura de forma bonita, com nomes de campos, em JSON, e até mesmo como escrever seu próprio método de impressão. Vamos lá!

▎1. A maneira mais simples: fmt.Println e suas limitações

Vamos começar pelo básico. Temos a estrutura:

package main\n\nimport "fmt"\n\ntype User struct {\n    Name   string\n    Age    int\n    Active bool\n}\n\nfunc main() {\n    u := User{Name: "Ana", Age: 30, Active: true}\n    fmt.Println(u)\n}\n

Saída:\n

{Ana 30 true}

Funciona, mas é pouco informativo. Você não vê qual valor pertence a qual campo. Se a estrutura tiver 10 campos, você ficará adivinhando o que é o quê. Especialmente se o tipo de dado se repetir (por exemplo, dois campos string consecutivos).

Conclusão: fmt.Println serve apenas para uma verificação rápida, quando a estrutura é pequena e você lembra exatamente a ordem dos campos.

Quando isso é útil?

\n
• Você está escrevendo um script descartável.
\n
• A estrutura contém 2-3 campos de tipos diferentes.
\n
• Você usa fmt.Println para logs, onde a velocidade é mais importante que a legibilidade.
\n

▎2. O salvador %+v: impressão com nomes de campos

Esta é, provavelmente, a resposta mais popular no Stack Overflow. O formato %+v no fmt.Printf exibe a estrutura com os nomes dos campos:

fmt.Printf("%+v\\n", u)\n

Saída:\n

{Name:Ana Age:30 Active:true}

Muito melhor! Você vê claramente onde está o nome, a idade e o status.

O que mais tem no arsenal do fmt?

\n
• %v — representação padrão (como no Println).
\n
• %+v — com nomes de campos.
\n
• %#v — representação completa com o pacote e o tipo (veja abaixo).
\n
• %T — exibe apenas o tipo da variável.
\n

Exemplo com %#v:

fmt.Printf("%#v\\n", u)\n// main.User{Name:"Ana", Age:30, Active:true}\n

Este formato é útil quando você quer copiar a saída e colá-la de volta no código — é uma inicialização literal válida da estrutura.

Dica: memorize a combinação %+v — é o seu pão de cada dia ao depurar estruturas em Go.

▎3. Beleza e organização: serialização em JSON

Quando a estrutura é grande, aninhada ou contém slices, o %+v pode se tornar ilegível. É aí que o JSON entra em cena. O Go nativamente consegue transformar uma estrutura em JSON:

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype Address struct {\n    City  string `json:"city"`\n    Street string `json:"street"`\n}\n\ntype User struct {\n    Name    string  `json:"name"`\n    Age     int     `json:"age"`\n    Active  bool    `json:"active"`\n    Address Address `json:"address"`\n}\n\nfunc main() {\n    u := User{\n        Name:   "João",\n        Age:    28,\n        Active: true,\n        Address: Address{\n            City:   "São Paulo",\n            Street: "Paulista",\n        }