Generate Typed Code from JSON — TypeScript, Python, Go, Rust & More

Por que Gerar Código a Partir de JSON?

Todo projeto que consome uma API JSON eventualmente precisa de modelos tipados. Você copia uma resposta de exemplo para seu editor, analisa os campos e começa a escrever uma interface ou struct manualmente. Funciona — até que a carga tenha 40 campos, três níveis de aninhamento e um array de objetos polimórficos. Então, torna-se tedioso, propenso a erros e lento.

Um gerador de código elimina essa etapa manual. Cole um exemplo de JSON, escolha uma linguagem e obtenha definições de tipo prontas para produção em segundos. Os benefícios são concretos:

• Economia de tempo — gerar tipos para uma carga de 50 campos leva segundos em vez de minutos.
• Segurança de tipo — seu compilador ou tempo de execução detecta incompatibilidades antes que cheguem à produção.
• Menos boilerplate — nada de escrever manualmente getters, setters, tags JSON ou anotações serde.
• Consistência — cada membro da equipe obtém os mesmos modelos a partir dos mesmos dados de origem.

Como Funciona a Inferência de Tipo

Um gerador de JSON para código lê seus dados de exemplo e infere um tipo para cada valor. Strings se tornam string, números se tornam int ou float dependendo da presença de um ponto decimal, booleanos mapeiam diretamente, e null produz um wrapper opcional/nulo. Objetos se tornam tipos nomeados (structs, classes, interfaces), e arrays se tornam coleções tipadas de qualquer que sejam seus elementos.

Veja como os tipos JSON se mapeiam entre as linguagens:

Tipo JSON	TypeScript	Python	Java	Go	Rust	Swift
string	string	str	String	string	String	String
number (int)	number	int	int	int64	i64	Int
number (float)	number	float	double	float64	f64	Double
boolean	boolean	bool	boolean	bool	bool	Bool
null	null	None	null	*T (ponteiro)	Option<T>	T?
object	interface	dataclass	class (POJO)	struct	struct	struct (Codable)
array	T[]	list[T]	List<T>	[]T	Vec<T>	[T]

A chave para entender: um gerador só sabe o que vê. Se seus dados de exemplo têm 42 para um campo que também pode ser 42.5, o gerador escolherá int em vez de float. Use dados de exemplo representativos para tipos precisos.

Exemplo de Entrada

Usaremos este JSON ao longo dos exemplos abaixo. Ele cobre strings, números, booleanos, um objeto aninhado e um array:

{
  "id": 1,
  "name": "Alice Johnson",
  "email": "alice@example.com",
  "active": true,
  "score": 97.5,
  "address": {
    "street": "123 Main St",
    "city": "Portland",
    "zip": "97201"
  },
  "tags": ["admin", "editor"]
}

Interfaces TypeScript a Partir de JSON

TypeScript é o alvo mais comum. O gerador cria uma interface para cada objeto, usando os nomes dos campos como chaves de propriedade:

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

interface Root {
  id: number;
  name: string;
  email: string;
  active: boolean;
  score: number;
  address: Address;
  tags: string[];
}

Cada campo é tipado, o objeto aninhado address recebe sua própria interface, e tags é inferido como string[] a partir de seu conteúdo. Você pode colar isso diretamente em seu projeto e começar a usá-lo com autocompletar completo e verificações em tempo de compilação.

Dataclasses Python a Partir de JSON

O decorador @dataclass do Python gera automaticamente os métodos __init__, __repr__ e de comparação. Combinado com dicas de tipo, é a maneira mais limpa de definir modelos JSON em Python:

from dataclasses import dataclass

@dataclass
class Address:
    street: str
    city: str
    zip: str

@dataclass
class Root:
    id: int
    name: str
    email: str
    active: bool
    score: float
    address: Address
    tags: list[str]

Combine isso com uma biblioteca como dacite ou cattrs para desserializar dicionários JSON diretamente nessas instâncias de dataclass.

POJOs Java a Partir de JSON

Java requer mais cerimônia — campos, um construtor e getters/setters. Um gerador economiza mais tempo aqui:

public class Address {
    private String street;
    private String city;
    private String zip;

    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    public String getZip() { return zip; }
    public void setZip(String zip) { this.zip = zip; }
}

public class Root {
    private int id;
    private String name;
    private String email;
    private boolean active;
    private double score;
    private Address address;
    private List<String> tags;

    // getters and setters...
}

Os POJOs gerados funcionam diretamente com Jackson, Gson ou qualquer outra biblioteca de serialização JSON no ecossistema Java.

Structs Go a Partir de JSON

Structs Go usam tags de campo para controlar a marshaling JSON. O gerador produz Go idiomático com campos exportados e tags json:"...":

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

type Root struct {
    ID      int64    `json:"id"`
    Name    string   `json:"name"`
    Email   string   `json:"email"`
    Active  bool     `json:"active"`
    Score   float64  `json:"score"`
    Address Address  `json:"address"`
    Tags    []string `json:"tags"`
}

As tags garantem que json.Unmarshal mapeie chaves JSON em minúsculas para campos Go exportados (em maiúsculas). Os nomes dos campos são automaticamente PascalCased, e id se torna ID seguindo as convenções de nomenclatura do Go.

Structs Rust a Partir de JSON

Rust usa a crate serde para serialização. O gerador adiciona os macros derive necessários:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct Address {
    pub street: String,
    pub city: String,
    pub zip: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Root {
    pub id: i64,
    pub name: String,
    pub email: String,
    pub active: bool,
    pub score: f64,
    pub address: Address,
    pub tags: Vec<String>,
}

Com serde_json, você pode desserializar uma string JSON nessas structs com uma única chamada para serde_json::from_str. O compilador garante que cada campo esteja presente e corretamente tipado.

Codable Swift a Partir de JSON

O protocolo Codable do Swift permite codificação e decodificação JSON integradas sem dependências externas:

struct Address: Codable {
    let street: String
    let city: String
    let zip: String
}

struct Root: Codable {
    let id: Int
    let name: String
    let email: String
    let active: Bool
    let score: Double
    let address: Address
    let tags: [String]
}

Use JSONDecoder().decode(Root.self, from: data) para analisar dados JSON diretamente nessas structs. O Swift infere as chaves de codificação a partir dos nomes das propriedades automaticamente.

Lidando com Objetos e Arrays Aninhados

Objetos aninhados são a parte mais interessante da geração de código. Quando o gerador encontra um valor de objeto dentro de outro objeto, ele cria um tipo nomeado separado. A convenção de nomenclatura é tipicamente baseada no nome do campo:

• Um campo chamado address contendo um objeto produz um tipo chamado Address.
• Um campo chamado shipping_details produz ShippingDetails (PascalCased).
• Objetos profundamente aninhados seguem o mesmo padrão recursivamente — um address com um objeto aninhado coordinates produz tanto os tipos Address quanto Coordinates.

Arrays de objetos são tratados de maneira semelhante. Se items é um array de objetos, o gerador examina o primeiro elemento (ou mescla todos os elementos) para inferir o tipo e cria um tipo de nome singular como Item.

Arrays de primitivos (["admin", "editor"]) são diretos — eles se tornam string[], Vec<String>, []string, etc., dependendo da linguagem de destino.

Dicas para Melhorar o Código Gerado

A qualidade dos tipos gerados depende inteiramente da qualidade dos seus dados de entrada. Algumas dicas práticas:

• Use dados de exemplo representativos. Inclua pelo menos um exemplo de cada variação de campo. Se um campo pode ser null, inclua um valor nulo para que o gerador o marque como opcional.
• Mantenha os tipos consistentes. Se id é um número em alguns registros e uma string em outros, o gerador terá que escolher um ou usar um tipo de união. Limpe seus dados de exemplo primeiro.
• Renomeie o tipo raiz. A maioria dos geradores usa Root como o nome de nível superior por padrão. Renomeie para algo significativo como User ou ApiResponse após gerar.
• Achate antes de gerar se você só precisa de um subconjunto da estrutura. Corte seu exemplo JSON para apenas os campos que você se importa.
• Verifique casos extremos. Arrays vazios ([]) não podem ser tipados sem contexto. Preencha-os com pelo menos um elemento para que o gerador saiba o tipo do item.
• Revise e ajuste. O código gerado é um ponto de partida. Você pode querer renomear campos, ajustar larguras de inteiros, adicionar anotações de validação ou marcar campos opcionais com base no seu conhecimento de domínio.

Experimente Você Mesmo

Gere código tipado instantaneamente: Cole qualquer JSON em nosso JSON para Código gerador e obtenha tipos prontos para produção para TypeScript, Python, Java, Go, Rust, Swift, Kotlin e C#. Nenhum cadastro necessário.