Trabalhando com JSON em Go: parsing e serialização de dados

Introdução ao Trabalho com JSON em Go

JSON (JavaScript Object Notation) é um dos formatos de troca de dados mais populares em aplicações web modernas, microsserviços e APIs. A linguagem Go (Golang) oferece suporte poderoso integrado para trabalhar com JSON através do pacote encoding/json. Este pacote permite converter facilmente dados entre estruturas Go e strings JSON, e vice-versa.

Neste artigo, examinaremos detalhadamente como realizar parsing (desserialização) e serialização de JSON em Go. Você aprenderá a trabalhar com estruturas simples e aninhadas, tratar erros e configurar nomes de campos. O material será útil tanto para iniciantes quanto para desenvolvedores experientes que desejam sistematizar seus conhecimentos.

Fundamentos da Serialização (Marshal) em Go

Convertendo uma Estrutura Go para JSON

Serialização é o processo de converter um objeto Go (por exemplo, uma estrutura ou slice) em uma string JSON. A função json.Marshal() é utilizada para isso. Vejamos um exemplo simples:

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string    Age   int    Email string}

func main() {    user := User{        Name:  "Ivan Petrov",        Age:   30,        Email: "ivan@example.com",    }

    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Println("Serialization error:", err)        return    }

    fmt.Println(string(jsonData))}

Saída do programa:

{"Name":"Ivan Petrov","Age":30,"Email":"ivan@example.com"}

Nota: os nomes dos campos em JSON correspondem aos nomes dos campos da estrutura. Mas muitas vezes é necessário alterá-los, por exemplo, para usar o estilo camelCase. Para isso, são utilizadas struct tags.

Usando Tags para Configurar JSON

Struct tags permitem especificar exatamente como um campo será serializado. Vamos adicionar tags ao nosso exemplo:

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

Agora a saída será:

{"name":"Ivan Petrov","age":30,"email":"ivan@example.com"}

Opções principais de tags:

• json:"field_name" — define o nome do campo em JSON.
• omitempty — exclui o campo do JSON se ele tiver um valor zero (string vazia, 0, false, nil).
• - — ignora completamente o campo durante serialização/desserialização.

Serialização de Slices e Mapas

O pacote encoding/json funciona bem não apenas com estruturas, mas também com slices, mapas e tipos simples:

// Slice de estruturasusers := []User{    {Name: "Anna", Age: 25},    {Name: "Boris", Age: 35},}jsonUsers, _ := json.Marshal(users)fmt.Println(string(jsonUsers))// Saída: [{"name":"Anna","age":25},{"name":"Boris","age":35}]

// Mapadata := map[string]interface{}{    "status": "ok",    "count":  42,}jsonMap, _ := json.Marshal(data)fmt.Println(string(jsonMap))// Saída: {"count":42,"status":"ok"}

Parsing de JSON (Unmarshal) em Go

Parsing Básico em uma Estrutura

Desserialização (parsing) é o processo inverso: converter uma string JSON em um objeto Go. A função json.Unmarshal() é utilizada. Importante: a estrutura de destino deve ser exportada (campos com letras maiúsculas) ou ter tags apropriadas.

jsonString := `{"name":"Maria","age":28,"email":"maria@example.com"}`

var user Usererr := json.Unmarshal([]byte(jsonString), &user)if err != nil {    fmt.Println("Parsing error:", err)    return}

fmt.Printf("Name: %s, Age: %d", user.Name, user.Age)// Saída: Name: Maria, Age: 28

Parsing de Estruturas Aninhadas

JSON frequentemente contém objetos aninhados.