Conversor JSON para TypeScript

O que é a conversão de JSON para TypeScript?

Cole um payload JSON e você recebe de volta interfaces TypeScript — contratos tipados que descrevem exatamente quais propriedades um objeto possui e qual tipo cada uma armazena. Sem elas, os dados retornados por JSON.parse() chegam como any, sem assistência do editor e sem verificações do compilador no acesso ou atribuição de propriedades. Converter JSON para TypeScript oferece essa segurança sem precisar escrever interfaces manualmente.

TypeScript cobre os seis tipos de valor JSON: string, number, boolean, null, object e array. Todo objeto JSON aninhado se torna sua própria interface nomeada. Arrays são tipados a partir do primeiro elemento. O resultado corresponde ao que JSON.parse() retorna em tempo de execução, portanto as interfaces refletem dados reais, não suposições.

Escrever interfaces manualmente para JSON grande ou profundamente aninhado é tedioso e sujeito a erros. Um gerador de JSON para TypeScript lê a estrutura automaticamente, trata o aninhamento de forma recursiva e produz código de interface limpo em segundos. Isso é especialmente útil ao integrar uma API desconhecida, prototipar com dados simulados ou migrar uma base de código JavaScript para TypeScript. Também libera você de rastrear manualmente nomes e tipos de propriedades aninhadas, para que possa focar na lógica da aplicação em vez de escrever código de tipos repetitivo.

Por que usar um gerador de JSON para TypeScript?

Gerar interfaces TypeScript manualmente é viável para objetos pequenos, mas se torna impraticável rapidamente com estruturas aninhadas ou respostas grandes de API. Considere uma resposta de API com 50 campos e três níveis de aninhamento — escrevê-la manualmente significa dezenas de interfaces, cada uma sendo uma fonte potencial de erros de digitação ou campos anuláveis esquecidos. Um gerador automatizado produz o conjunto completo em milissegundos e reduz a chance de incompatibilidades de tipo entre o seu código e os dados que ele consome. Além da precisão, ele mantém seus tipos sincronizados com o contrato real da API. Quando um serviço muda o formato da resposta, basta colar o JSON atualizado e regenerar — muito mais rápido do que localizar cada propriedade alterada em um arquivo de interface escrito à mão.

Casos de uso de JSON para TypeScript

Referência de Mapeamento de Tipos JSON para TypeScript

Cada valor JSON mapeia para um tipo TypeScript. A tabela abaixo mostra como cada primitivo e tipo estrutural JSON é traduzido. Esse mapeamento segue o padrão JSON ECMA-404 e os tipos nativos do TypeScript.

interface vs type alias no TypeScript

TypeScript oferece duas formas de descrever formatos de objetos: declarações de interface e aliases de type. Ambos funcionam para representar estruturas JSON, mas diferem em extensão e comportamento de mesclagem. A maioria dos geradores de JSON para TypeScript produz interfaces porque são a escolha idiomática para formatos de objetos em TypeScript.

Exemplos de Código

Abaixo estão exemplos de geração de interfaces TypeScript a partir de JSON em diferentes linguagens e ferramentas. Cada trecho produz saída executável.

// Manual interface definition from a JSON shape
const json = '{"id": 1, "name": "Alice", "active": true}';
const parsed = JSON.parse(json);

interface User {
  id: number;
  name: string;
  active: boolean;
}

const user: User = parsed;
console.log(user.name); // "Alice" — fully typed

import JsonToTS from 'json-to-ts';

const json = {
  id: 1,
  name: "Alice",
  address: { street: "123 Main St", city: "Springfield" },
  tags: ["admin", "user"]
};

const interfaces = JsonToTS(json, { rootName: "User" });
console.log(interfaces.join("\n\n"));
// interface Address {
//   street: string;
//   city: string;
// }
//
// interface User {
//   id: number;
//   name: string;
//   address: Address;
//   tags: string[];
// }

# Install: pip install datamodel-code-generator
# Generate TypeScript-style types from JSON using Pydantic models

# Command line:
# datamodel-codegen --input data.json --output model.py

# Or generate TypeScript directly with quicktype:
# pip install quicktype
# quicktype --lang ts --src data.json --out types.ts

import json

data = {"id": 1, "name": "Alice", "scores": [98, 85, 92]}

# Python equivalent using TypedDict (Python 3.8+)
from typing import TypedDict, List

class User(TypedDict):
    id: int
    name: str
    scores: List[int]

user: User = data  # type-checked by mypy

# Install quicktype globally
npm install -g quicktype

# Generate TypeScript interfaces from a JSON file
quicktype --lang ts --src data.json --out types.ts

# From a JSON string via stdin
echo '{"id": 1, "name": "Alice"}' | quicktype --lang ts

# Output:
# export interface Root {
#   id:   number;
#   name: string;
# }

Perguntas Frequentes