Generador de código desde JSON

¿Qué es un generador de código desde JSON?#

Un generador de código desde JSON lee un documento JSON de muestra, deduce la forma de los datos —qué campos son cadenas, cuáles son números, cuáles objetos anidados, cuáles arrays de qué— y escribe los tipos de entidad que un programa real usaría para almacenar esos datos. En lugar de codificar a mano una interfaz de TypeScript, una clase de Java, un struct de Go o una clase de C# para encajar con una respuesta de API, pegas una respuesta de ejemplo y obtienes los tipos listos para incorporar a tu proyecto.

Por debajo, recorre el valor analizado e infiere un esquema. Los objetos anidados se convierten en su propio tipo con nombre; el tipo del elemento de un array es la fusión de la forma de todos los elementos (así, una lista de objetos que no todos tienen las mismas claves produce un único tipo con la unión de los campos). Los nombres de campo que no son identificadores válidos —una clave con guion como first-name, o una que empiece por un dígito— se sanean a un identificador legal y la clave original se conserva como anotación de serialización, de modo que el viaje de ida y vuelta sigue funcionando.

La salida es código fuente de texto plano sin dependencia en tiempo de ejecución de esta página. Cópialo, pégalo en tu base de código, ajusta los nombres de los tipos y tendrás un punto de partida: no un modelo terminado, pero sí el esqueleto aburrido ya escrito por ti.

Cómo usarlo#

1. Elige el destino con el desplegable Lenguaje: TypeScript, Java, Go o C#.
2. Ajusta el Nombre raíz (por defecto Root). Se convertirá en el nombre del tipo más exterior, por ejemplo User, Order, Response.
3. Pega tu JSON en el panel de la izquierda. El código generado aparece en vivo a la derecha; la línea de estado reporta errores (JSON no válido, entrada vacía).
4. Pulsa Copiar para llevar el código al portapapeles.
5. Ejemplo carga un objeto anidado con un sub-objeto y un array; Limpiar vacía ambos paneles.

Características principales#

• Cuatro lenguajes destino. Interfaces TypeScript, clases Java, structs Go y clases C#: una entrada, cuatro salidas, con un desplegable.
• Inferencia de esquema, no tipado literal. Los objetos anidados se convierten en tipos con nombre; los arrays de objetos producen un tipo de elemento con nombre en lugar de una lista opaca any.
• Fusión de arrays heterogéneos. Cuando los elementos de un array tienen campos distintos, el tipo inferido es la unión, útil para respuestas reales desordenadas en las que no todos los elementos tienen todas las claves.
• Identificador seguro, clave fiel. Las claves que no son identificadores válidos se sanean y la clave original se conserva como anotación de serialización (@JsonProperty, una etiqueta json: de Go, JsonPropertyName), así el JSON original se deserializa correctamente.
• En vivo y local. La generación se ejecuta en tu navegador según escribes o cambias opciones; los datos nunca salen de la página.

Ejemplo detallado#

Carga Ejemplo con Lenguaje en TypeScript y Nombre raíz Root, y la entrada es:

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

El generador emite dos interfaces —la raíz y un tipo Address con nombre para el objeto anidado:

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

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

Cambia el lenguaje a Go y la misma entrada se convierte en structs con etiquetas json: que conservan las claves originales:

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"`
}

Fíjate en que id, un número JSON, cae como number en TypeScript y float64 en Go: el generador no adivina entero frente a coma flotante, porque el propio JSON no los distingue.

Preguntas frecuentes#

¿Por qué mi campo entero se tipa como float64 / Double / double?#

Porque JSON tiene un único tipo de número y no puede distinguir 5 de 5.0. El generador mapea cada número JSON al tipo numérico general del lenguaje destino —number en TypeScript, Double en Java, float64 en Go, double en C#—, así el tipo siempre es lo bastante amplio para contener cualquier valor que resulte ser. Si sabes que un campo es siempre entero, estúchalo a int / Long / int64 a mano después.

¿Qué pasa cuando los objetos de mi array no tienen todos los mismos campos?#

Se fusionan sus formas. Un array como [{ "a": 1 }, { "a": 2, "b": "x" }] produce un tipo de elemento con a y b, así un único tipo cubre todos los elementos. Si dos elementos discrepan en el tipo de un campo de forma incompatible (pongamos un número aquí, una cadena allí), ese campo degrada a any / Object en lugar de elegir un lado y equivocarse con el otro.

Un campo de mi JSON lleva un guion, como first-name. ¿Lo romperá?#

No. El generador convierte first-name en un identificador legal (firstName) como nombre del campo y emite una anotación de serialización que registra la clave original —@JsonProperty("first-name") en Java, una etiqueta json:"first-name" en Go, [JsonPropertyName("first-name")] en C# y una clave entre comillas "first-name" en TypeScript. El código generado, por tanto, deserializa el JSON original sin cambios.

¿Qué hace con un valor null?#

Un campo cuyo valor es null se trata como tipo desconocido. En TypeScript se convierte en un any opcional (field?: any;); en Java y C# pasa a ser Object / object; en Go, interface{}. Es una señal deliberada: null no te dice nada sobre qué contiene el campo cuando sí está presente, así que el generador se niega a adivinar y te lo deja para que lo rellenes.