Nenhum conteúdo ainda
Cole JSON à esquerda, e as definições de tipo struct Go prontas para uso direto em projetos Go são geradas automaticamente à direita. Processamento local puro no navegador, sem registro ou upload necessário.
JSON para Go é o processo de conversão automática de dados em formato JSON para definições de tipo struct da linguagem Go. JSON é o formato de troca de dados mais comum em APIs REST, arquivos de configuração, filas de mensagens e logs, enquanto Go é uma linguagem fortemente tipada; durante o desenvolvimento, a estrutura dinâmica de JSON frequentemente precisa ser mapeada para struct antes da desserialização com encoding/json. Escrever structs manualmente, especialmente objetos aninhados, facilmente leva a campos ausentes ou tipos incorretos; esta ferramenta visa automatizar o trabalho repetitivo.
O struct de Go é um tipo de dados composto, declarado com `type Name struct { ... }`. Cada campo consiste em nome e tipo; nomes de campos devem começar com letra maiúscula para serem acessíveis por outros pacotes, os chamados 'identificadores exportados'. A ferramenta converte automaticamente nomes de campos JSON para nomes de campos exportados PascalCase, ex. `user_name` mapeia para `UserName`, com a chave original preservada na tag json.
A conversão central desta ferramenta é realizada pelo Web Worker jsonFormat no navegador, chamando o renderizador Go do quicktype-core com opções `just-types` e `no-comments`. Todo o fluxo não depende de serviços backend: o JSON de entrada é analisado localmente, tipos inferidos, código Go gerado, finalmente apresentado no editor direito.
A inferência de tipos segue o mapeamento convencional JSON para Go: strings mapeiam para `string`, booleanos para `bool`, inteiros para `int64`, floats para `float64`, arrays para slices `[]T`, objetos para structs independentes, `null` para `interface{}`. Objetos aninhados são processados recursivamente, mantendo hierarquia clara.
Comparado à escrita manual, código gerado por ferramenta é um 'primeiro rascunho executável'. Desenvolvedores geralmente só precisam ajustar nome do tipo raiz, nome do pacote, precisão do tipo de campo (ex. int64 para int) e se usar tipos ponteiro, antes de colocar em projetos Go reais. Combinado com cópia em um clique e download model.go, o trabalho repetitivo nas fases de integração e modelagem é significativamente reduzido.
Após copiar struct gerado para o projeto, desserialize diretamente resposta API com encoding/json.
package main
import (
"encoding/json"
"fmt"
)
// Código gerado pela ferramenta GeekFormat JSON para Go
type User struct {
ID int64 `json:"id"`
Name string `json:"name"`
Tags []string `json:"tags"`
Address Address `json:"address"`
}
type Address struct {
City string `json:"city"`
}
func main() {
data := []byte(`{
"id": 1,
"name": "Alice",
"tags": ["admin", "dev"],
"address": {"city": "Beijing"}
}`)
var u User
if err := json.Unmarshal(data, &u); err != nil {
panic(err)
}
fmt.Println(u.Name, u.Address.City)
}Se alguns campos API podem não existir, altere campos correspondentes para tipos ponteiro ou use com tag omitempty.
package main
import "encoding/json"
// Altere manualmente campos para ponteiros; quando ausentes, valor é nil
type User struct {
ID *int64 `json:"id,omitempty"`
Name *string `json:"name,omitempty"`
Email *string `json:"email,omitempty"`
}
func main() {
data := []byte(`{"id": 1, "name": "Bob"}`)
var u User
json.Unmarshal(data, &u)
if u.Email == nil {
println("Campo Email ausente")
}
}Cole o conteúdo JSON na caixa de entrada à esquerda, a ferramenta converterá automaticamente em 400ms e exibirá o struct Go gerado à direita. Você também pode arrastar e soltar arquivos .json/.txt, ou clicar em 'Exemplo' para carregar dados integrados. Após a conversão, copie ou baixe o arquivo model.go em um clique.
Sim. A ferramenta gera código Go baseado em quicktype-core, e por padrão cada campo struct inclui tag `json:"nome_original"`, prático para serialização e desserialização diretas com Unmarshal/Marshal do encoding/json.
Sim. Arrays JSON geram tipos slice correspondentes com base nos tipos de elementos, ex. `["a","b"]` gera `[]string`, `[1,2,3]` gera `[]int64`, `[{...},{...}]` gera tipos personalizados como `[]UserItem`.
Sim. Cada objeto aninhado gera recursivamente um tipo struct independente, nomeado em PascalCase. Por exemplo, o objeto `address` gera um struct `Address`, referenciado no struct principal através do campo `Address Address`.
Valores null em JSON geralmente são inferidos como `interface{}`, que é o tipo de segurança padrão. Se você souber o tipo real do campo, pode adicionar um valor de exemplo no JSON, regenerar, depois ajustar manualmente para o tipo específico.
Sim. A ferramenta usa o nome do tipo raiz (como User) por padrão; após modificar o nome do tipo raiz nas configurações, todos os nomes de subtipos associados são atualizados sincronamente, o nome do arquivo baixado também muda consequentemente.
A ferramenta detecta automaticamente a validade JSON. Se existirem erros comuns como vírgulas finais, aspas simples, aspas ausentes, aparece o botão 'Reparar JSON'. Ao clicar, a ferramenta tentará reparo automático e regenerará o struct Go; quando o reparo falhar, a posição específica do erro é indicada.
Não. Toda análise JSON, inferência de tipos e geração de código Go são concluídas no seu navegador via Web Worker; o conteúdo de entrada e o código gerado nunca são enviados a nenhum servidor, nem registrados na nuvem. JSON sensível contendo chaves API, tokens ou dados de negócios pode ser usado com segurança.
Sim. O código gerado é struct Go padrão com tags json, pode ser copiado diretamente para o diretório types/ ou models/ do projeto. Recomendamos ajustar nomes de tipos e nomes de pacote de acordo com as convenções de nomenclatura do projeto.
Completamente gratuita, sem registro ou login necessário. Abra a página e use imediatamente, sem limites de funcionalidades, marcas d'água ou login forçado.
A ferramenta não tem limite de tamanho de arquivo estrito, mas velocidade de conversão e desempenho de renderização dependem do desempenho do navegador e dispositivo. Recomendamos processar JSON dentro de 1MB para melhor experiência; para JSON superdimensionado, processe primeiro com formatador JSON ou ferramenta de divisão.
Não. A ferramenta distingue inteiros e floats: campos inteiros geram int64, campos float geram float64. Se preferir tipos mais específicos como int, uint64, substitua manualmente após a geração.
Caixa de entrada à esquerda está vazia ou contém apenas espaços em branco. Por favor cole JSON válido, ou clique em 'Exemplo' para carregar dados, ou arrasta e solta arquivos .json/.txt.
Clique no botão 'Reparar JSON' abaixo da caixa de entrada; a ferramenta tentará automaticamente reparar vírgulas finais, aspas simples, aspas ausentes, objetos estilo JS e outros problemas. Resultado modificado será destacado após reparo.
A ferramenta gera nomes de campos PascalCase a partir de chaves JSON. Se chaves contiverem chinês ou caracteres especiais, podem ser gerados nomes de campos com escape. Recomendamos alterar chaves JSON para inglês minúsculo ou snake_case, depois ajustar uniformemente após geração.
Como null não pode inferir tipo específico, a ferramenta usa interface{} como fallback. Você pode dar a este campo um valor de exemplo (como "" ou 0) no JSON fonte, regenerar e depois mudar o tipo para tipo real como string/int64.
Renderização do navegador de JSON superdimensionado e grandes quantidades de structs consome muita memória. Recomendações: ① mantenha apenas campos chave no JSON de exemplo; ② divida em vários objetos e converta separadamente; ③ feche outras abas que consomem memória no navegador.
Quando o array está vazio [] ou tipos de elementos são inconsistentes, a ferramenta usa interface{} como fallback. Você pode adicionar elementos de exemplo do mesmo tipo, ou alterar manualmente o tipo para tipos slice específicos como []string, []int64 após geração.
Esta ferramenta infere automaticamente tipos Go correspondentes com base no tipo de valor JSON; mapeamentos comuns são os seguintes:
| Exemplo valor JSON | Tipo Go gerado | Nota |
|---|---|---|
"hello" | string | Mapeamento direto de string |
true / false | bool | Valor booleano |
42 | int64 | Número sem ponto decimal |
3.14 | float64 | Número com ponto decimal |
null | interface{} | Segurança padrão quando tipo específico não pode ser inferido |
["a","b"] | []string | Array de strings |
[1,2,3] | []int64 | Array de inteiros |
[{...},{...}] | []UserItem | Array de objetos, tipos de elementos gerados recursivamente |
{"id":1} | User | Objeto gera struct independente |
Ferramenta usa int64 e float64 por padrão; ajuste conforme necessidades em projetos reais:
| Cenário | Tipo recomendado | Motivo |
|---|---|---|
| IDs inteiros gerais, contagens | int64 | Consistente com padrão da ferramenta, compatível com maioria dos números JSON |
| PK autoincremental de banco de dados conhecida como positiva | uint64 | Evita números negativos, semântica mais clara |
| Sistemas 32 bits ou inteiros de pequeno intervalo explícito | int32 | Reduz consumo de memória |
| Preços, coordenadas, cálculo científico | float64 | Consistente com padrão da ferramenta, precisão float padrão |
| Cálculo monetário preciso | decimal.Decimal / int | float64 tem risco de precisão; recomenda shopspring/decimal ou int em unidade de centavos |
Todo o processamento desta ferramenta JSON para Go é concluído completamente localmente no seu navegador: análise JSON, inferência de tipos, geração de código Go são todos executados lado cliente via Web Worker; o conteúdo JSON de entrada, arquivos carregados e código Go gerado nunca são enviados a nenhum servidor, nem registrados, em cache ou armazenados na nuvem. Após fechar ou atualizar a página, todo o conteúdo de entrada e saída é automaticamente apagado da memória, apenas localStorage mantém o histórico de entradas recentes (pode ser apagado a qualquer momento). Adequado para processamento de JSON contendo chaves API, tokens, dados de negócios sensíveis.