Processamento JSON em Go (Golang): guia completo com exemplos

Processamento JSON em Go (Golang): guia completo

Go (Golang) é uma linguagem de programação compilada moderna, desenvolvida no Google. Um de seus pontos fortes é o suporte nativo ao formato JSON através do pacote padrão encoding/json. Ao contrário de muitas outras linguagens, onde é necessário instalar bibliotecas de terceiros, em Go o processamento JSON está disponível "de fábrica" e se destaca pelo alto desempenho e tipagem forte.

Neste artigo, vamos detalhar todos os aspectos do trabalho com JSON em Go: desde parsing simples até cenários complexos com tipos personalizados e processamento em fluxo.

Fundamentos: codificação e decodificação JSON

O pacote encoding/json fornece duas funções principais: json.Marshal() para serializar estruturas Go em JSON e json.Unmarshal() para desserializar JSON de volta em estruturas.

Exemplo: serialização de estrutura para JSON

package main

import (    "encoding/json"    "fmt")

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

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

    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Println("Erro de serialização:", err)        return    }

    fmt.Println(string(jsonData))    // Saída: {"name":"Ivan Petrov","age":30,"email":"ivan@example.com"}}

Exemplo: desserialização de JSON para estrutura

func main() {    jsonString := `{"name":"Anna Smirnova","age":25,"email":"anna@example.com"}`        var user User    err := json.Unmarshal([]byte(jsonString), &user)    if err != nil {        fmt.Println("Erro de desserialização:", err)        return    }

    fmt.Printf("Nome: %s, Idade: %d, Email: %s", user.Name, user.Age, user.Email)}

Tags de Estrutura (Struct Tags)

As tags de estrutura em Go permitem controlar como os campos serão serializados em JSON. Este é um mecanismo poderoso para configurar nomes de campos, omitir valores vazios e outras opções.

Opções principais de tags:

• json:"name" — define o nome do campo em JSON
• json:"-" — exclui completamente o campo do JSON
• json:"name,omitempty" — omite o campo se ele contiver valor zero (0, "", false, nil)
• json:"name,string" — converte forçadamente um campo numérico em string

Exemplo com diferentes tags:

type Product struct {    ID          int     `json:"id"`    Title       string  `json:"title"`    Description string  `json:"description,omitempty"`    Price       float64 `json:"price,string"`    SecretKey   string  `json:"-"`}

func main() {    product := Product{        ID:          101,        Title:       "Notebook",        Description: "",        Price:       899.99,        SecretKey:   "sk-12345",    }

    jsonData, _ := json.MarshalIndent(product, "", "  ")    fmt.Println(string(jsonData))    // Saída:    // {    //   "id": 101,    //   "title": "Notebook",    //   "price": "899.99"    // }}

Trabalhando com dados JSON arbitrários (interface{})

Às vezes, a estrutura dos dados JSON não é conhecida antecipadamente. Nesses casos, pode-se usar o tipo interface{} ou map[string]interface{}.

func main() {    jsonString := `{"name":"Teste","values":[1,2,3],"active":true,"metadata":{"version":2}}`        var data map[string]interface{}    err := json.Unmarshal([]byte(jsonString), &data)    if err != nil {        fmt.Println("Erro:", err)        return    }

    // Acesso aos valores com conversão de tipos    name := data["name"].(string)    values := data["values"].([]interface{})