O pacote encoding/json da biblioteca padrão do Go trata a serialização (marshaling) e desserialização (unmarshaling) de JSON, mapeando entre structs Go e JSON. Tags de struct controlam a nomenclatura dos campos, e é a base da maioria das APIs web em Go.
User {
Name
Email
Age
private
}
u := User{Name: , Email: , Age: }
data, err := json.Marshal(u)
fmt.Println((data))
json.Marshal converte um struct em bytes JSON. Apenas campos exportados (capitalizados) são serializados — campos não exportados são ignorados.
type Product struct {
ID int `json:"id"` // → "id"
Name string `json:"product_name"` // → "product_name" (rename)
Price float64 `json:"price,omitempty"` // omit if 0
Notes string `json:"-"` // "-" → NEVER serialize this field
}
Sem tags, as chaves JSON usam como padrão o nome exato do campo (capitalizado). Tags permitem controlar o nome da chave JSON, omitir valores vazios (omitempty), e excluir campos inteiramente (-) — essencial para corresponder às convenções de API (ex. JSON em snake_case).
jsonData := []byte(`{"name":"Bob","email":"[email protected]","age":25}`)
var user User
err := json.Unmarshal(jsonData, &user) // pass a POINTER to populate it
if err != nil { log.Fatal(err) }
fmt.Println(user.Name) // "Bob"
json.Unmarshal analisa JSON em um struct — você deve passar um ponteiro para que ele possa preencher o struct. Os campos são correspondidos por tag/nome (case-insensitively).
// when the structure is unknown, unmarshal into a map or interface{}
var result map[string]interface{}
json.Unmarshal(data, &result)
name := result["name"].(string) // type-assert the value (JSON numbers → float64!)
// encode directly to an io.Writer (e.g. an HTTP response) — efficient, no intermediate buffer
json.NewEncoder(w).Encode(user)
// decode directly from an io.Reader (e.g. an HTTP request body)
json.NewDecoder(r.Body).Decode(&user)
Para servidores web, Encoder/Decoder trabalham diretamente com streams (corpos de requisição/resposta) — o padrão comum em handlers.
A codificação/decodificação de JSON é fundamental para praticamente todo o desenvolvimento web em Go — APIs REST, microsserviços e configuração dependem todos de converter entre structs Go e JSON.
O pacote encoding/json (biblioteca padrão, sem dependências) é a ferramenta padrão, e compreendê-lo bem é conhecimento essencial do dia a dia: como marshaling/unmarshaling funcionam, a regra crítica de que apenas campos exportados são serializados, e especialmente tags de struct (controlando nomes de chaves JSON com json:"...", omitempty para pular valores vazios, - para excluir) que são necessárias para corresponder às convenções de API do mundo real como snake_case.
Saber passar um ponteiro para Unmarshal, lidar com JSON dinâmico via maps/interface{} (com a particularidade de que números JSON decodificam para float64), e usar streaming Encoder/Decoder para corpos HTTP cobre as necessidades práticas de construir APIs.
É uma parte constante e prática do trabalho backend em Go.