JSON a Tipos (TS/Go)

Convierta payloads JSON en interfaces TypeScript, esquemas Zod, JSON Schema o structs Go al instante en su navegador. 100% gratis y sin servidores.

Entrada JSON

Conectando payloads JSON dinámicos con lenguajes fuertemente tipados

Los servicios web modernos se comunican casi universalmente mediante JSON (JavaScript Object Notation, RFC 8259). Sin embargo, escribir backends críticos en Go (Golang) o frontends con seguridad de tipos en TypeScript requiere definiciones de tipos estrictas en tiempo de compilación. Redactar manualmente docenas de interfaces anidadas o campos de structs a partir de documentación de API o respuestas cURL es tedioso, propenso a errores y un gran cuello de botella durante la integración.

El Convertidor de JSON a TypeScript y Go de OmniTools realiza un recorrido recursivo del árbol de sintaxis abstracta (AST) sobre payloads JSON de muestra, generando definiciones de tipos limpias, idiomáticas y listas para producción al instante en su navegador.

Generación de interfaces TypeScript: Mecánica del tipado estructural

TypeScript opera bajo subtipado estructural (llamado coloquialmente "duck typing"). Los tipos existen únicamente como contratos en tiempo de compilación y se eliminan por completo durante la compilación a JavaScript (tsc).

1. Interfaces frente a alias de tipos (Type Aliases)

Nuestro generador produce bloques limpios de export interface:

  • Fusión de declaraciones (Declaration Merging): Las interfaces admiten la fusión abierta de declaraciones y la herencia mediante extends, lo que las convierte en la opción estándar para contratos de payloads de API y propiedades de componentes en aplicaciones React, Vue y Angular.
  • Rendimiento: El compilador de TypeScript almacena en caché internamente las formas de las interfaces por nombre, lo que resulta en pasadas de verificación de tipos más rápidas que los alias de tipos anónimos profundamente anidados.

2. Manejo de propiedades opcionales frente a anulables (Nullable)

En TypeScript, existe una diferencia semántica fundamental entre una propiedad opcional y un valor anulable:

  • Clave opcional (title?: string): La clave misma puede omitirse del objeto JSON (equivalente a string | undefined).
  • Valor anulable (title: string | null): La clave debe estar presente en el payload, pero su valor puede ser el literal null.

3. Inferencia de tipos en arreglos

Al inspeccionar arreglos, el generador verifica la homogeneidad de los elementos. Si todos los elementos comparten un esquema de objeto idéntico, emite un arreglo fuertemente tipado (por ejemplo, items: UserItem[]). Si los elementos son primitivas mixtas, sintetiza un tipo de unión idiomático (por ejemplo, tags: (string | number)[]).

4. Inmutabilidad y transformaciones con Utility Types

En los frameworks modernos de gestión de estado (como Redux Toolkit, Zustand o Vue Pinia), los payloads de frontend a menudo deben tratarse como objetos inmutables. Envolver su interfaz generada en Readonly<T> (o marcar propiedades individuales con el modificador readonly) evita la mutación accidental del estado en los hooks del ciclo de vida de sus componentes.

Arquitectura de Structs en Go: Tipado nominal y encoding/json

A diferencia de TypeScript, Go (Golang) es un lenguaje compilado con tipado estático nominal y diseños de memoria exactos en tiempo de ejecución. Los campos de un struct dictan directamente los desplazamientos de memoria binaria y las reglas de reflexión.

1. La regla de visibilidad PascalCase

Go impone la visibilidad a nivel de paquete mediante el uso de mayúsculas iniciales:

  • Con mayúscula inicial (Upper Case, ej. UserName): Campo exportado. Visible para paquetes externos, incluido el serializador estándar encoding/json.
  • Con minúscula inicial (ej. userName): Campo no exportado (privado). ¡El analizador JSON de Go ignorará silenciosamente este campo y nunca lo poblará durante json.Unmarshal()!

Nuestro motor convierte automáticamente las claves JSON en snake_case y kebab-case en identificadores PascalCase limpios mientras adjunta etiquetas de struct precisas.

2. Sintaxis de etiquetas de Struct (Struct Tags) en Go

Para asociar campos PascalCase con claves JSON sin procesar, Go utiliza etiquetas de campo entre acentos graves (backticks):

type UserProfile struct {
    ID        int64  `json:"id"`
    FirstName string `json:"first_name"`
    Email     string `json:"email,omitempty"`
}

3. La dicotomía numérica: int frente a float64

En la especificación oficial de JSON, solo existe un tipo genérico number (almacenado como punto flotante IEEE 754 de 64 bits). En Go, los desarrolladores deben elegir entre int, int64 y float64:

  • Los números enteros sin parte fraccionaria (por ejemplo, 100) se tipan como int o int64.
  • Los números que contienen fracciones decimales (por ejemplo, 99.95) se tipan como float64.
  • Para una precisión monetaria extrema o satoshis de criptomonedas, los ingenieros suelen asignar los campos a json.Number o tipos decimales personalizados para evitar imprecisiones de punto flotante.

El patrón de punteros: Anulabilidad y omitempty en Go

Uno de los obstáculos más frecuentes en el desarrollo backend con Go es distinguir entre valores cero (zero values) y valores ausentes o nulos:

La trampa del valor cero

En Go, cada tipo tiene un valor cero intrínseco: 0 para enteros, "" para cadenas y false para booleanos. Si un cliente envía un payload de actualización destinado a establecer la edad de un usuario en 0, una etiqueta estándar Age int `json:"age,omitempty"` omitirá el campo por completo durante la serialización, confundiendo el valor válido 0 con un campo vacío.

La solución con punteros

Para preservar la semántica de null y la opcionalidad, declare el campo como un puntero:

type UpdateRequest struct {
    DisplayName *string `json:"display_name,omitempty"`
    Score       *int    `json:"score,omitempty"`
}

Si se omite display_name o se envía como null, el puntero será nil. Si se envía como "", será un puntero que apunta a una cadena vacía, lo que permite que la lógica de su aplicación distinga sin ambigüedades las actualizaciones intencionales de los campos omitidos.

Modelado avanzado: Uniones discriminadas y polimorfismo

Payloads polimórficos en TypeScript: Uniones discriminadas

Los eventos de webhooks del mundo real (como los de Stripe, GitHub o Shopify) suelen devolver payloads polimórficos donde la estructura depende de una etiqueta discriminadora "type" o "event". En TypeScript, modelar esto con una única interfaz monolítica llena de propiedades opcionales da como resultado un tipado débil:

/* Patrón idiomático de unión discriminada */
interface PaymentSuccessEvent {
  type: 'payment.success';
  amount: number;
  receiptUrl: string;
}

interface PaymentFailedEvent {
  type: 'payment.failed';
  errorCode: string;
  retryAfter: number;
}

export type WebhookEvent = PaymentSuccessEvent | PaymentFailedEvent;

Cuando evalúa event.type en un bloque switch, TypeScript estrecha automáticamente el tipo en cada rama, evitando el acceso en tiempo de ejecución a propiedades no válidas.

Payloads polimórficos en Go: json.RawMessage

Dado que Go impone tipos estáticos estrictos, analizar JSON polimórfico requiere una deserialización en dos etapas utilizando json.RawMessage:

type WebhookEnvelope struct {
    Type string          `json:"type"`
    Data json.RawMessage `json:"data"` // Retrasa la deserialización
}

func HandleWebhook(payload []byte) error {
    var env WebhookEnvelope
    if err := json.Unmarshal(payload, &env); err != nil {
        return err
    }
    switch env.Type {
    case "payment.success":
        var data PaymentSuccess
        return json.Unmarshal(env.Data, &data)
    }
    return nil
}

Arquitectura en producción: Comparación entre TypeScript y Go

Característica del lenguaje Interfaz TypeScript Struct de Go
Sistema de tipos Subtipado estructural (solo en tiempo de compilación) Tipado estático nominal (modelo de memoria en ejecución)
Mapeo de campos Idéntico a los nombres de clave JSON Identificador PascalCase + etiqueta `json:"key"`
Payloads dinámicos Record<string, any> o unknown map[string]any o json.RawMessage
Validación en ejecución Requiere esquemas Zod, Yup o io-ts La deserialización nativa falla ante discrepancias de tipos

Serialización temporal: Cadenas ISO 8601 frente a tipos nativos

El dilema de las fechas en JSON

La especificación oficial de JSON (RFC 8259) no incluye un tipo de datos nativo para fechas o marcas de tiempo. Las marcas de tiempo se transmiten casi universalmente como cadenas ISO 8601 (por ejemplo, "2026-10-22T14:30:00Z") o enteros de época UNIX (por ejemplo, 1792683000).

  • En TypeScript: Por defecto, los analizadores JSON deserializan las cadenas de fecha en primitivas string sin procesar. Si necesita objetos Date nativos de JavaScript, su aplicación debe analizarlos explícitamente o utilizar un validador de esquemas en tiempo de ejecución (como Zod z.string().datetime().transform((str) => new Date(str))).
  • En Go: La biblioteca estándar encoding/json de Go ofrece soporte integrado para marcas de tiempo RFC 3339. Si declara un campo de struct como time.Time (por ejemplo, CreatedAt time.Time `json:"created_at"`), Go analizará automáticamente la cadena ISO 8601 durante la deserialización y fallará con un error claro si el formato es inválido.

Structs anidados con nombre frente a Structs anónimos en línea

Cuando un objeto JSON contiene objetos secundarios anidados, ¿debería generar structs con nombre separados o un struct anónimo en línea?

  • Structs anónimos en línea: Ideales para payloads de solicitud rápidos y puntuales donde el objeto secundario nunca se pasa a funciones auxiliares separadas.
  • Structs independientes con nombre (Recomendado): Separar los objetos secundarios en declaraciones de nivel superior (por ejemplo, UserAddress, OrderBilling) hace que su código sea reutilizable entre funciones manejadoras, mapeadores de bases de datos y pruebas unitarias.

Casos de uso prácticos en el mundo real

  • Integrar una API de terceros: Pegue una respuesta de API de muestra para generar al instante una interfaz TypeScript base o un struct de Go con sus etiquetas json.
  • Modelar payloads de webhooks: Genere definiciones fuertemente tipadas para payloads de eventos entrantes desde pasarelas de pago o servicios de notificaciones.
  • Estructurar modelos de estado en el frontend: Cree tipos de TypeScript directamente a partir de una respuesta del backend en lugar de escribir a mano campos profundamente anidados.
  • Definir manejadores de solicitud y respuesta en Go: Convierta payloads JSON de muestra en structs de Go para acelerar la implementación de endpoints en el backend.
  • Verificar tipos en fixtures de pruebas: Genere definiciones de tipos precisas para payloads JSON simulados utilizados en suites de pruebas unitarias y de integración.

Privacidad Absoluta

Compilación AST 100% en el navegador. Los payloads de API contienen frecuentemente correos electrónicos confidenciales de usuarios, tokens de autenticación, saldos financieros y esquemas de bases de datos propietarios.

OmniTools ejecuta todo el análisis de JSON, la inspección recursiva de esquemas y la generación de código localmente en el entorno de ejecución JavaScript de su navegador. Ningún dato JSON se transmite jamás por internet, ni se registra en servidores externos ni se almacena en caché en bases de datos en la nube.

Preguntas Frecuentes (FAQ)

¿Cómo convertir un objeto JSON en interfaces TypeScript, structs de Go, esquemas Zod o JSON Schema?

Pegue su respuesta JSON y elija entre TypeScript, Go, Zod o JSON Schema para generar al instante interfaces tipadas anidadas, estructuras de Go con etiquetas json:"...", validadores Zod (z.object con z.infer) o definiciones JSON Schema (Draft 2020-12) listas para producción.

¿Es seguro pegar payloads JSON de APIs privadas en este conversor?

Sí. Toda la inferencia de tipos, esquemas Zod y JSON Schema se ejecuta 100% en su navegador local sin transmitir datos a ningún servidor.