Conversor JSON para Go Struct

O que é a conversão de JSON para Go Struct?

A conversão de JSON para Go transforma dados JSON brutos em definições de tipos Go que funcionam com o pacote encoding/json da biblioteca padrão do Go. Go é estaticamente tipado, portanto cada campo JSON precisa de um campo struct correspondente com o tipo correto e uma struct tag que indica ao serializador qual chave JSON mapear. Escrever essas definições manualmente para respostas de API grandes ou profundamente aninhadas é lento e sujeito a erros.

O pacote encoding/json, definido na especificação do Go desde a versão 1.0, usa reflexão para associar chaves JSON a campos struct exportados. A correspondência não diferencia maiúsculas de minúsculas por padrão, mas json struct tags explícitas são a prática padrão porque eliminam ambiguidade e permitem usar a convenção PascalCase do Go enquanto o JSON permanece em camelCase ou snake_case. Um conversor automatiza tudo isso: lê seu JSON, infere tipos Go a partir dos valores e produz definições struct com as tags corretas.

O sistema de tipos do Go mapeia de forma limpa para JSON. Strings se tornam string, booleanos se tornam bool, inteiros se tornam int e números de ponto flutuante se tornam float64. Objetos JSON aninhados se tornam structs nomeadas separadas, e arrays se tornam slices. A única lacuna é o null: Go não tem um tipo nullable universal, portanto valores null tipicamente se tornam tipos ponteiro (*string, *int) ou interface{}. Um gerador cuida de tudo isso em milissegundos.

Por que usar um conversor de JSON para Go?

Definir structs Go a partir de JSON manualmente significa contar chaves, adivinhar tipos e reescrever tags toda vez que a API muda. Um conversor elimina esse atrito.

Casos de uso de JSON para Go Struct

Mapeamento de Tipos JSON para Go

O pacote encoding/json segue regras específicas ao mapear valores JSON para tipos Go. A tabela abaixo mostra o mapeamento padrão e alternativas comuns. A coluna "Padrão" mostra o que a maioria dos geradores produz. A coluna "Alternativa" mostra tipos que você pode escolher com base nos seus requisitos, como int64 para IDs grandes ou tipos ponteiro para campos anuláveis.

Referência de Struct Tags JSON do Go

Struct tags controlam como encoding/json serializa e desserializa campos. A tag json é de longe a mais comum, mas você pode combiná-la com outras tags (db, yaml, xml) no mesmo campo. A sintaxe da tag é uma string delimitada por crases após o tipo do campo. A seguir estão as opções de tag json suportadas por encoding/json.

json.Unmarshal vs json.NewDecoder

Go oferece duas formas de decodificar JSON: json.Unmarshal para byte slices e json.NewDecoder para streams io.Reader. Ambos usam as mesmas regras de struct tags, mas diferem em quando utilizá-los.

Exemplos de Código

Estes exemplos mostram como usar structs Go geradas a partir de JSON em programas reais, além de como gerá-las a partir de outras linguagens. Os exemplos Go usam encoding/json da biblioteca padrão.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email"`
	IsActive bool     `json:"is_active"`
	Tags     []string `json:"tags"`
}

func main() {
	data := []byte(`{"id":1,"name":"Alice","email":"alice@example.com","is_active":true,"tags":["admin","editor"]}`)

	var user User
	if err := json.Unmarshal(data, &user); err != nil {
		panic(err)
	}
	fmt.Println(user.Name)  // → Alice
	fmt.Println(user.Tags)  // → [admin editor]
}

// JSON response from API — this is the shape you'd convert to Go:
const res = await fetch("https://api.example.com/users/1");
const user = await res.json();
// user → { "id": 1, "name": "Alice", "email": "alice@example.com" }

// Equivalent Go struct:
// type User struct {
//     ID    int    `json:"id"`
//     Name  string `json:"name"`
//     Email string `json:"email"`
// }

import json

def json_to_go(data: dict, name: str = "Root") -> str:
    lines = [f"type {name} struct {{"]
    type_map = {str: "string", int: "int", float: "float64", bool: "bool"}

    for key, value in data.items():
        go_type = type_map.get(type(value), "interface{}")
        field = key.title().replace("_", "")  # snake_case → PascalCase
        lines.append(f'\t{field} {go_type} `json:"{key}"`')
    lines.append("}")
    return "\n".join(lines)

data = json.loads('{"user_name": "Alice", "age": 30, "verified": true}')
print(json_to_go(data))
# type Root struct {
#     UserName string `json:"user_name"`
#     Age      int    `json:"age"`
#     Verified bool   `json:"verified"`
# }

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Event struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

func main() {
	stream := strings.NewReader(`{"type":"click","payload":"btn-1"}
{"type":"scroll","payload":"page-2"}`)

	dec := json.NewDecoder(stream)
	for dec.More() {
		var ev Event
		if err := dec.Decode(&ev); err != nil {
			break
		}
		fmt.Printf("%s: %s\n", ev.Type, ev.Payload)
	}
	// → click: btn-1
	// → scroll: page-2
}

Perguntas Frequentes