Gerador de código a partir de JSON

O que é um gerador de código a partir de JSON?#

Um gerador de código a partir de JSON lê um documento JSON de exemplo, descobre a forma dos dados — que campos são strings, que são números, que são objetos aninhados, que são arrays de quê — e escreve os tipos de entidade que um programa real usaria para guardar esses dados. Em vez de codificar à mão uma interface TypeScript, uma classe Java, uma struct Go ou uma classe C# para corresponder a uma resposta de API, cola uma resposta de exemplo e obtém os tipos prontos a largar no seu projeto.

Por baixo, percorre o valor analisado e infere um esquema. Objetos aninhados tornam-se o seu próprio tipo nomeado; o tipo do elemento de um array é a fusão da forma de todos os elementos (pelo que uma lista de objetos que nem todos têm as mesmas chaves ainda produz um tipo com a união dos campos). Nomes de campo que não são identificadores válidos — uma chave com hífens como first-name, ou uma que comece por um dígito — são sanitizados num identificador legal e a chave original é preservada como anotação de serialização, pelo que a viagem completa (round-trip) continua a funcionar.

A saída é código-fonte em texto simples sem dependência em tempo de execução desta página. Copie, cole na sua base de código, ajuste os nomes dos tipos, e tem um ponto de partida — não um modelo acabado, mas o esqueleto aborrecido já escrito por si.

Como usar#

1. Escolha o destino no menu Linguagem: TypeScript, Java, Go ou C#.
2. Defina o Nome raiz (predefinição Root). Isto torna-se o nome do tipo mais exterior — por exemplo User, Order, Response.
3. Cole o seu JSON no painel da esquerda. O código gerado aparece em tempo real à direita; a linha de estado reporta erros (JSON inválido, entrada vazia).
4. Clique em Copiar para levar o código para a área de transferência.
5. Exemplo carrega um objeto aninhado com um sub-objeto e um array; Limpar repõe ambos os painéis.

Principais funcionalidades#

• Quatro linguagens de destino. Interfaces TypeScript, classes Java, structs Go e classes C# — uma entrada, quatro saídas, alternadas com um menu.
• Inferência de esquema, não tipagem literal. Objetos aninhados tornam-se tipos nomeados; arrays de objetos produzem um tipo de elemento nomeado em vez de uma lista opaca de any.
• Fusão de arrays heterogéneos. Quando os elementos do array têm campos diferentes, o tipo inferido é a união — útil para respostas reais confusas em que nem todos os itens têm todas as chaves.
• Identificador seguro, chave fiel. Chaves que não são identificadores válidos são sanitizadas, e a chave original é mantida como anotação de serialização (@JsonProperty, uma tag Go json:, JsonPropertyName), pelo que o JSON original ainda desserializa corretamente.
• Em tempo real e local. A geração corre no seu navegador à medida que escreve ou altera opções; os dados nunca saem da página.

Exemplo prático#

Carregue em Exemplo com a Linguagem definida como TypeScript e Nome raiz Root, e a entrada é:

{
  "id": 1,
  "name": "Ada",
  "active": true,
  "address": { "city": "London", "zip": "NW1" },
  "tags": ["math", "logic"]
}

O gerador emite duas interfaces — a raiz e um tipo Address nomeado para o objeto aninhado:

export interface Root {
  id: number;
  name: string;
  active: boolean;
  address: Address;
  tags: Array<string>;
}

export interface Address {
  city: string;
  zip: string;
}

Mude a linguagem para Go e a mesma entrada torna-se structs com tags json: que preservam as chaves originais:

package model

type Root struct {
  Id       float64   `json:"id"`
  Name     string    `json:"name"`
  Active   bool      `json:"active"`
  Address  Address   `json:"address"`
  Tags     []string  `json:"tags"`
}

type Address struct {
  City  string  `json:"city"`
  Zip   string  `json:"zip"`
}

Repare como id, um número JSON, aterra como number em TypeScript e float64 em Go — o gerador não adivinha inteiro versus vírgula flutuante, porque o próprio JSON não os distingue.

FAQ#

Porque é que o meu campo inteiro é tipado como float64 / Double / double?#

Porque o JSON tem um único tipo de número e nenhuma forma de distinguir 5 de 5.0. O gerador mapeia todos os números JSON para o tipo numérico geral da linguagem de destino — number em TypeScript, Double em Java, float64 em Go, double em C# — pelo que o tipo é sempre suficientemente amplo para conter o que o valor vier a ser. Se souber que um campo é sempre inteiro, estreite-o para int / Long / int64 à mão depois.

O que acontece quando os objetos do meu array não têm todos os mesmos campos?#

As suas formas são fundidas. Um array como [{ "a": 1 }, { "a": 2, "b": "x" }] produz um tipo de elemento com ambos a e b, pelo que um único tipo cobre todos os itens. Se dois elementos discordarem quanto ao tipo de um campo de forma incompatível (digamos um número aqui, uma string ali), esse campo degrada para any / Object em vez de escolher um lado e enganar-se sobre o outro.

Um campo do meu JSON tem um hífen, como first-name. Vai partir?#

Não. O gerador transforma first-name num identificador legal (firstName) para o nome do campo e emite uma anotação de serialização que registra a chave original — @JsonProperty("first-name") em Java, uma tag json:"first-name" em Go, [JsonPropertyName("first-name")] em C# e uma chave entre aspas "first-name" em TypeScript. O código gerado, portanto, desserializa o JSON original inalterado.

O que faz com um valor null?#

Um campo cujo valor seja null é tratado como tipo desconhecido. Em TypeScript torna-se num any opcional (field?: any;); em Java e C# torna-se Object / object; em Go, interface{}. Esse é um sinal deliberado — null não diz nada sobre o que o campo contém quando está presente, pelo que o gerador se recusa a adivinhar e deixa-o para preencher.