Um guia para usar JSON em Go

JSON (JavaScript Object Notation) é um formato de dados altamente versátil e muito popular. Geralmente é usado para comunicação entre aplicativos da Web e também como uma maneira conveniente de armazenar grandes quantidades de dados de aplicativos estruturados.

JSON é tão útil que quase todas as linguagens de programação modernas fornecem suporte integrado para trabalhar com ele, incluindo Go.

Trabalhando com JSON em Go

Você pode dividir a maior parte do trabalho que fará com JSON em duas categorias gerais: empacotamento e desempacotamento. Wikipédia define marshaling como:

Na ciência da computação, empacotamento é o processo de transformar a representação da memória de um objeto em um formato de dados adequado para armazenamento ou transmissão. É normalmente usado quando os dados devem ser movidos entre diferentes partes de um programa de computador ou de um programa para outro.

Em termos mais simples, marshaling é o processo de converter dados armazenados em uma variável em um formato que seja mais fácil de passar para outro programa. Unmarshaling é o processo inverso: envolve pegar dados formatados para transporte e convertê-los em um formato que seja mais fácil de usar pelo seu programa.

Usando Go, você pode agrupar estruturas de dados nativas em JSON. E você pode executar a ação inversa, desempacotando dados JSON em variáveis ​​Go.

Empacotamento para JSON em Go

Go fornece o codificação/pacote json para facilitar o trabalho com JSON. Este pacote contém várias funções, mas a que você usará para marshaling é a Marechal função. Marechal tem a seguinte assinatura de função:

Func Marechal (v interface{}) ([]byte, erro)

Isso significa que Marechal aceita um parâmetro de qualquer tipo de dados e retorna dois valores: uma fatia de bytes e um erro. Em outras palavras, você chama Marechal com um valor Go, converte-o em JSON e retorna o equivalente em JSON. Se encontrar um erro durante o processo de conversão, retornará o erro e uma fatia vazia.

Aqui está um exemplo de código que usa Marechal para converter um mapa em JSON. Para executar este exemplo, tudo que você precisa é criar um arquivo Go em seu editor de código favorito, ou use o Vá para o playground:

pacote principal
importar (
"codificação/json"
"fmt"
)
função principal(){
 val := mapa[string]int{
"John": 25,
"Mary": 19,
"Adão": 5,
 }
res, _ := json. Marechal (val)
fmt.Println(corda(res))
}

Se você executar esse código, ele produzirá o seguinte:

Como mencionado anteriormente, você pode empacotar qualquer tipo de dados Go para JSON, embora na vida real você normalmente esteja empacotando structs. Por causa disso, o Go fornece um recurso chamado struct tags para permitir que você forneça Marechal instruções extras para converter suas estruturas.

Uma tag struct é uma string que você inclui em sua declaração struct ao lado do tipo de dados de um campo. As tags struct permitem que você ajuste a maneira Marechal trata o campo ao qual o tag pertence. Você pode usar tags struct para renomear um campo na saída JSON ou até mesmo omiti-lo totalmente. Tags de estrutura (que Marechal reconhece) começam com a substring "json:".

Por exemplo, digamos que você tenha uma estrutura Carro que representa algumas informações sobre um carro. Aqui está o código para criar um Carro e marshal para JSON:

pacote principal
importar (
"codificação/json"
"fmt"
)
função principal(){
tipo Estrutura do carro {
 Cadeia de marcas
 Cadeia modelo
 Preço int
 }
 val := Carro{Marca: "Mercedes", Modelo: "Benz", Preço: 50000}
 res, _ := json. Marechal (val)
fmt.Println(corda(res))
}

Este código produz a saída:

O Marca, Modelo, e Preço campos de Carro precisa começar com letras maiúsculas, ou Marechal não será capaz de convertê-los. Isso resulta em campos de saída JSON começando com letras maiúsculas também. Mas e se você quiser que os nomes comecem com letras minúsculas no JSON ou se quiser renomear um campo completamente? É aí que entram as tags struct. Aqui está um exemplo:

pacote principal
importar (
"codificação/json"
"fmt"
)
função principal(){
tipo Estrutura do carro {
 ID int `json:"-"`
 String de marca `json:"tipo"`
 Cadeia de modelo `json:"modelo"`
 Preço int `json:"preço"`
 }
 val := Carro{ID: 0, Marca: "Mercedes", Modelo: "Benz", Preço: 50000}
 res, _ := json. Marechal (val)
fmt.Println(corda(res))
}

Este código introduz um novo campo de ID que Marechal omite da saída JSON por meio de uma tag struct. O código também usa tags struct para renomear os outros campos struct. Aqui está a saída do programa:

Como você pode ver, a parte da tag struct após "json:" torna-se o nome do campo na saída do Marshal. Há uma exceção: se for a string "-", Marshal omite esse campo da saída. Você pode ler mais sobre tags Marshal e struct no Ir documentação.

Unmarshaling de JSON em Go

O pacote encoding/json também fornece uma função de unmarshaling, chamada Unmarshal. Possui a seguinte assinatura de função:

func Unmarshal (data []byte, v interface{}) erro

Diferente Marechal, Unmarshal não retorna um valor. Em vez disso, ele aceita JSON como uma fatia de bytes no primeiro argumento e armazena os dados convertidos no objeto apontado por seu segundo argumento. Unmarshal funciona com tags struct também, mas aqui, as tags dizem Unmarshal quais campos JSON correspondem a quais campos struct.

Ao desempacotar em um programa, você pode buscar dados de uma API, mas aqui você estará usando dados fictícios. Veja como você usa Unmarshal:

pacote principal
importar (
"codificação/json"
"fmt"
)
função principal(){
tipo Estrutura do carro {
 ID int `json:"-"`
 String de marca `json:"tipo"`
 Cadeia de modelo `json:"modelo"`
 Preço int `json:"preço"`
 }
jsonInput := `{
"tipo": "Toyota",
"modelo": "camry",
"preço": 2000
 }`
var jsonOutput Car
 erro := json. Unmarshal([]byte(jsonInput), &jsonOutput)
se errar != nil {
 fmt. Imprimirln("Erro de decodificação JSON!")
retornar
 }
fmt.Println(jsonOutput)
}

Esse código usa o mesmo tipo Car do exemplo anterior e desempacota um objeto JSON em uma estrutura do tipo Car e, em seguida, imprime os dados na estrutura. Quando executado, o programa produz esta saída:

Isso mostra que os dados JSON fictícios foram desempacotados com sucesso no jsonOutput struct.

Go facilita o trabalho com JSON

Com o pacote encoding/json, trabalhar com JSON em Go é tão simples quanto duas chamadas de função: Marshaland Unmarshal. Go também permite personalizar o processo de empacotamento/desempacotamento de JSON com tags struct.

A conversão de dados para JSON é uma ótima maneira de compartilhá-los com outro programa ou processo. O formato é tão universal que o JSON é tão portátil quanto possível.