Trabalhando com JSON em Go: parsing e serialização para iniciantes

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 e microsserviços. Graças à sua simplicidade e legibilidade, o JSON se tornou padrão para APIs REST, arquivos de configuração e armazenamento de dados estruturados.

A linguagem Go (Golang) oferece suporte nativo poderoso para JSON através do pacote encoding/json. Este pacote permite converter facilmente estruturas Go para JSON (serialização) e vice-versa (desserialização ou parsing).

Neste artigo, abordaremos os fundamentos do trabalho com JSON em Go: desde exemplos simples até o tratamento de estruturas aninhadas complexas e erros. O material é voltado para desenvolvedores iniciantes que já conhecem os conceitos básicos da sintaxe do Go.

Serialização: convertendo estruturas Go para JSON

Serialização (codificação) é o processo de converter dados da representação interna do Go (structs, slices, maps) em uma string JSON. Em Go, utiliza-se a função json.Marshal().

Exemplo básico de serialização

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype Person struct {\n    Name string\n    Age  int\n    City string\n}\n\nfunc main() {\n    person := Person{\n        Name: "João Silva",\n        Age:  30,\n        City: "São Paulo",\n    }\n\n    jsonBytes, err := json.Marshal(person)\n    if err != nil {\n        fmt.Println("Erro de serialização:", err)\n        return\n    }\n\n    fmt.Println(string(jsonBytes))\n    // Saída: {"Name":"João Silva","Age":30,"City":"São Paulo"}\n}

Observe: json.Marshal() retorna um slice de bytes ([]byte), por isso o convertemos para string usando string().

Saída formatada com json.MarshalIndent

Para depuração ou exibição legível, use json.MarshalIndent():

jsonBytes, err := json.MarshalIndent(person, "", "  ")\nif err != nil {\n    fmt.Println("Erro:", err)\n    return\n}\nfmt.Println(string(jsonBytes))\n// Saída:\n// {\n//   "Name": "João Silva",\n//   "Age": 30,\n//   "City": "São Paulo"\n// }

Serialização de slices e maps

Go permite serializar não apenas structs, mas também outros tipos de dados:

// Slice de structs\npeople := []Person{\n    {Name: "Ana", Age: 25, City: "Rio"},\n    {Name: "Pedro", Age: 35, City: "Belo Horizonte"},\n}\njsonBytes, _ := json.Marshal(people)\nfmt.Println(string(jsonBytes))\n// Saída: [{"Name":"Ana","Age":25,"City":"Rio"},{"Name":"Pedro","Age":35,"City":"Belo Horizonte"}]\n\n// Map\nscores := map[string]int{"Álgebra": 5, "Física": 4, "Informática": 5}\njsonBytes, _ = json.Marshal(scores)\nfmt.Println(string(jsonBytes))\n// Saída: {"Álgebra":5,"Física":4,"Informática":5}

Parsing JSON: convertendo JSON para estruturas Go

Parsing (desserialização) é o processo inverso: a partir de uma string JSON, obtemos uma estrutura Go. Para isso, utiliza-se a função json.Unmarshal().

Parsing em uma struct

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype Person struct {\n    Name string\n    Age  int\n    City string\n}\n\nfunc main() {\n    jsonString := `{"Name":"João Silva","Age":30,"City":"São Paulo"}`\n\n    var person Person\n    err := json.Unmarshal([]byte(jsonString), &person)\n    if err != nil {\n        fmt.Println("Erro de parsing:", err)\n        return\n    }\n\n    fmt.Printf("Nome: %s, Idade: %d, Cidade: %s\\n", person.Name, person.Age, person.City)\n    // Saída: Nome: João Silva, Idade: 30, Cidade: São Paulo\n}

Importante: passe um ponteiro para a struct (&person), caso contrário, Unmarshal não conseguirá modificar seus campos.

Parsing em map[string]interface{}

Se a estrutura de dados não for conhecida antecipadamente, pode-se usar um tipo genérico:

jsonString := `{"name":"Ana","