JSON to Types

Pegá un ejemplo de JSON y generá interfaces TypeScript, tipos Python o Go equivalentes. Todo se calcula en tu navegador.

Actualizado:

100% client-side

Entrada JSON

0 caracteres

Tipos generados


        
—

¿Qué es JSON to Types?

JSON to Types convierte un ejemplo de JSON — de una respuesta de API, un archivo de configuración o una exportación de base de datos — en las definiciones de tipos equivalentes para TypeScript, Python o Go, para que no tengas que escribir y mantener a mano interfaces que se desincronizan de los datos reales. Infiere el tipo de cada campo a partir de los valores reales, detecta qué campos son opcionales o nulos, y genera un tipo con nombre por cada forma de objeto distinta.

Cómo usar JSON to Types

  1. Pegá un ejemplo de JSON en el panel de entrada JSON, o hacé clic en Ejemplo.
  2. Configurá un Nombre del tipo raíz si querés algo distinto de "Root".
  3. Elegí TypeScript, Python o Go como lenguaje de salida arriba del panel Tipos generados.
  4. Leé los tipos generados y hacé clic en Copiar para obtenerlos.

Cómo funciona JSON to Types

La herramienta recorre tu valor JSON parte por parte: cada objeto se convierte en un tipo con nombre (interface, TypedDict/dataclass o struct), los elementos de cada array se inspeccionan y se combinan en un único tipo de elemento, y cada valor primitivo se mapea a su equivalente más cercano en TypeScript/Python/Go. Cuando un array contiene varios objetos, los compara campo por campo: una clave presente en todos los objetos es obligatoria; una clave que falta en al menos un objeto se vuelve opcional; una clave cuyo valor a veces es null se convierte en un tipo nulable en su lugar (son dos cosas distintas, detectadas de forma independiente). Cuando los elementos de un array tienen tipos primitivos genuinamente distintos (por ejemplo, una mezcla de números y strings), la herramienta mantiene un tipo unión real en vez de generalizar todo silenciosamente a any.

// Entrada
{
  "id": 1,
  "name": "Ada",
  "tags": ["pioneer", "mathematician"],
  "roles": [
    { "name": "admin", "level": 1 },
    { "name": "editor", "level": 2, "temporary": true }
  ]
}

// TypeScript generado
interface Role {
  name: string;
  level: number;
  temporary?: boolean;
}

interface Root {
  id: number;
  name: string;
  tags: string[];
  roles: Role[];
}

Dos objetos anidados que resultan tener exactamente la misma forma (por ejemplo, un "billingAddress" y un "shippingAddress" con los mismos campos) se combinan en un solo tipo generado en vez de duplicarse, y una clave JSON que no es un identificador válido en el lenguaje destino (como "foo-bar") se maneja según el lenguaje: entre comillas en TypeScript, como una llamada funcional TypedDict(...) en Python, o conservando la clave real en una etiqueta json de Go junto a un nombre de campo saneado. Go no tiene un tipo unión nativo, así que un campo cuyos valores varían genuinamente de forma cae en el any de Go.

Ejemplos

1. Un struct de Go para una respuesta de API que trae un null. Con el Nombre del tipo raíz en User, las claves en snake_case se convierten en campos exportados de Go con etiquetas json, así que encoding/json los sigue asociando a los nombres originales. Un null no dice nada del tipo, por lo que last_login sale como any; cámbialo por el tipo real (un puntero como *string si puede ser nulo). La herramienta escribe UserId; si sigues la convención de Go para siglas, renómbralo a UserID, que la etiqueta mantiene la asociación:

// JSON
{"user_id": 42, "email": "[email protected]", "last_login": null}

// Go
package main

type User struct {
	UserId int `json:"user_id"`
	Email string `json:"email"`
	LastLogin any `json:"last_login"`
}

2. Un array cuyos elementos no tienen todos los mismos campos. Con el nombre raíz Product, los dos elementos se fusionan en un solo tipo: discount solo aparece en el segundo, así que pasa a ser opcional, y la raíz es un array de ese tipo. La pestaña de dataclass de Python da la misma forma como price: float y discount: Optional[float] = None:

// JSON
[{"sku": "A1", "price": 9.5}, {"sku": "B2", "price": 12, "discount": 0.1}]

// TypeScript
interface Product {
  sku: string;
  price: number;
  discount?: number;
}

type Root = Product[];

Si tus datos de ejemplo están en una hoja de cálculo, pásalos primero a JSON con el Conversor de CSV a JSON; si el JSON no se puede leer, el JSON Formatter te muestra dónde está el error.

Preguntas frecuentes

¿Cómo decide cuándo un campo es opcional?

Cuando tu JSON de entrada es un array de objetos, un campo se marca como opcional solo si falta en al menos uno de los objetos del array. Un campo que siempre está presente pero a veces es null se convierte en un tipo nulable en su lugar (por ejemplo, "string | null"), que es algo distinto a ser opcional.

¿Qué pasa con un array vacío?

Un array vacío no tiene nada de donde inferir el tipo de sus elementos, así que se tipifica como unknown[] (TypeScript), List[Any] (Python) o []any (Go), y la herramienta muestra una nota explicándolo.

¿Detecta la forma de los objetos anidados?

Sí. Cada objeto anidado obtiene su propia interface/class/struct con nombre, derivado de su clave padre. Si dos claves distintas generan exactamente la misma forma, comparten un solo tipo generado en vez de duplicarlo.

¿El resultado en Go o Python está garantizado que compile tal cual?

Es un punto de partida sólido, no una garantía. Las claves JSON que no son identificadores válidos se manejan (comillas en TypeScript, un TypedDict funcional en Python, un nombre saneado más la clave real en una etiqueta json de Go), pero igual conviene revisar el código generado antes de usarlo.