JSON Swiss

JSON Swiss

Gerador de JSON para Go

Entrada JSON

Carregando editor…

Go Gerado

Configuration

Insira dados JSON para gerar structs Go

Structs Go com tags JSON e mapeamento correto de tipos

Como converter JSON para Go – guia passo a passo

Use este gerador JSON to Go para criar estruturas Go com tags JSON a partir de amostras JSON para APIs e serviços.

  1. Passo 1 – Cole uma amostra JSON

    • Cole um objeto ou matriz JSON representativo no editor esquerdo.
    • Inclua objetos aninhados, matrizes e campos anuláveis para que os tipos sejam inferidos corretamente.
    • Use Import para carregar JSON de um arquivo, URL ou dados de amostra.

  2. Passo 2 – Escolha as opções de estrutura Go

    • Defina uma raiz Struct Name (por exemplo Root).
    • Decida como lidar com campos opcionais (*string, omitempty ou tipos personalizados).
    • Confirme as tags JSON e a nomenclatura para que as chaves sejam mapeadas corretamente (por exemplo, json:"createdAt").

  3. Passo 3 – Revise o código gerado

    • Verifique nomes de campos, tipos e como matrizes/objetos são modelados.
    • Ajuste opções como Root Type Name, tratamento nulo e estruturas, se disponíveis.
    • Se um campo for inferido incorretamente, ajuste seu JSON de amostra e gere-o novamente.

  4. Passo 4 – Use as estruturas em Go

    • Cole as estruturas em seu pacote e execute gofmt.
    • Desmarque com encoding/json no tipo raiz.
    • Adicione validação (por exemplo, campos obrigatórios) no limite da API.

  5. Passo 5 – Copiar ou baixar

    • Copie a saída em seu projeto ou baixe-a como um arquivo.
    • Execute seu formatador/linter para corresponder ao seu estilo de código.
    • Adicione bibliotecas de análise/serialização JSON se sua linguagem exigir.

Dicas rápidas

  • Use ponteiros para campos anuláveis quando precisar distinguir os ausentes dos vazios.
  • Prefira time.Time somente quando você controlar o formato do carimbo de data/hora.
  • Mantenha as estruturas DTO separadas dos modelos de domínio interno quando necessário.
Saída de exemplo (simplificada)
// Entrada JSON
{
  "id": 123,
  "name": "Maeve Winters",
  "email": "[email protected]",
  "active": true,
  "roles": ["admin", "editor"],
  "metadata": { "plan": "pro" },
  "createdAt": "2024-03-01T10:15:00Z",
  "score": 99.5,
  "notes": null
}

// Generated Go structs (simplified)
type Metadata struct {
  Plan string `json:"plan"`
}

type Root struct {
  ID        int       `json:"id"`
  Name      string    `json:"name"`
  Email     *string   `json:"email"`
  Active    bool      `json:"active"`
  Roles     []string  `json:"roles"`
  Metadata  Metadata  `json:"metadata"`
  CreatedAt string    `json:"createdAt"`
  Score     float64   `json:"score"`
  Notes     any       `json:"notes"`
}

Ferramentas JSON e Go relacionadas

Explore mais ferramentas JSON e de esquema que funcionam muito bem junto com este gerador JSON to Go.

Vá estruturar para JSON e esquema JSON

Converta estruturas Go existentes em exemplos JSON e esquema JSON para documentos e validação.

Gerador de esquema JSON

Gere um esquema JSON a partir de amostras JSON para validar cargas e contratos.

Formatador e validador JSON

Formate e valide o JSON antes de gerar estruturas para evitar problemas de tempo de execução.

JSON para gerador de ferrugem

Gere estruturas Rust com serde quando desejar uma digitação estrita.

Editor de tabela

Interface visual em tabela com edição de dados JSON em tempo real

Perguntas Frequentes

Quais recursos de Go são suportados?

O gerador cria definições de structs Go com tags JSON, suporta structs embutidas, tipos ponteiro para campos opcionais e segue convenções de nomenclatura do Go.

Como as tags JSON são tratadas?

As structs geradas incluem tags json para mapear nomes corretamente. Campos opcionais usam omitempty para tornar o encoding mais flexível.

Como slices e arrays são tratados?

Arrays JSON são mapeados para slices Go ([]Type) com o tipo de elemento correto. Arrays aninhados e estruturas complexas são suportados.

Como objetos aninhados são tratados?

Objetos aninhados geram definições de struct separadas, e relacionamentos são tratados por campos embutidos ou referenciados.