Genera tipos Go a partir de ejemplos JSON completos

Genera tipos Go a partir de ejemplos JSON. Conserva las claves con etiquetas json y los números con json.Number; revisa campos opcionales y null.

JSON a Go

Declaraciones Go 1.22+; sólo encoding/json y biblioteca estándar.

Todos los números usan json.Number para conservar sus lexemas. Los punteros opcionales aceptan null aunque no aparezca en las muestras y colapsan ausencia/null a nil; omitempty puede omitir null explícito. Raw conserva el token null. Los structs no exigen campos requeridos ni rechazan null escalar. Las claves fuera del subconjunto de tags amplían el objeto completo a un mapa raw.

Activa JavaScript para generar código. Puedes leer y editar el JSON.

Todos los elementos y documentos aportan al mismo contrato. Un array raíz sigue siendo un array. La ausencia de un campo es distinta de null.

Hasta 20 documentos, 1.000.000 de unidades UTF-16 de entrada y 2.000.000 de salida; también se aplican otros presupuestos de recursos.

Tu JSON se procesa localmente en un Worker del navegador. No se envía ni se guarda.

Modo de entrada

JSON del ejemplo activoCargar archivo local UTF-8

Nombre del tipo raíz

Usa entre 1 y 64 letras y dígitos ASCII; comienza por una letra. Los nombres reservados se rechazan.

Listo para introducir JSON.

Genera tipos Go a partir de tus ejemplos

Pega un documento JSON completo o abre un archivo UTF-8. Puedes aportar hasta veinte muestras para deducir tipos comunes. Se revisan todos los elementos, incluidos los campos que solo aparecen al final de un array. Una raíz array sigue siendo un array en Go.

[{"id":1},{"id":2,"nombre":"Ana"}]

package generated

import "encoding/json"

type RootItem struct {
  Id json.Number `json:"id"`
  Nombre *string `json:"nombre,omitempty"`
}

type Root []RootItem

En el ejemplo, Id usa json.Number. Como nombre falta en el primer objeto, Nombre se genera como puntero opcional con omitempty. El nombre original de cada propiedad queda en su etiqueta json.

La entrada debe ser JSON estricto. Las claves duplicadas, los comentarios, las comas finales, los documentos concatenados y las muestras vacías detienen la generación.

Cómo se conservan las claves

Las claves no vacías que cumplen [A-Za-z0-9_ .:/-]+ se representan con campos exportados y etiquetas JSON exactas. Si dos claves producen el mismo identificador Go, se cambia el identificador, no la clave. La clave literal - usa la etiqueta json:"-," o json:"-,omitempty".

Si una clave contiene caracteres que no caben en esas etiquetas, como comillas, coma, barra inversa o Unicode, el objeto completo usa un tipo basado en map[string]json.RawMessage. Este mapa conserva las claves Unicode válidas. Los objetos vacíos también usan mapas; una clave con un sustituto Unicode aislado impide generar código.

Propiedades ausentes y valores null

Los campos opcionales usan *T y omitempty, salvo los representados como JSON sin deserializar. Un tipo que admite null también usa un puntero. Los valores presentes false, cero o cadena vacía conservan un puntero distinto de nil.

Con un puntero, tanto una propiedad ausente como un null explícito pueden acabar en nil. Al serializar después, omitempty puede omitir ese null. En cambio, json.RawMessage permite distinguir una ausencia de los bytes del valor null recibido.

Deserializar en Go no comprueba que estén presentes todos los campos que parecían obligatorios en las muestras, ni rechaza siempre null en los escalares. Los tipos generados necesitan validaciones adicionales si tu aplicación depende de esas reglas.

Números y tipos que no se pueden concretar

Todos los números usan json.Number, incluidos 9007199254740993, 1.0, 1e3 y -0. Su método String() conserva el texto sin convertirlo a float64. Un aviso de precisión del analizador no significa que json.Number haya perdido esos dígitos.

Cuando no hay datos suficientes para deducir un tipo, solo se observa null o se mezclan varios tipos distintos de null, se usa json.RawMessage y se muestra un aviso. Las raíces numéricas o sin tipo concreto usan alias; una raíz que admite objeto o null usa un alias a puntero.

El código se genera en package generated con las declaraciones e importaciones necesarias, sin un deserializador propio. El navegador no compila ni ejecuta el resultado.

Límites y descarga

Límite	Máximo
Muestras	20
Texto de entrada total	1.000.000 unidades UTF-16 / 4.000.000 bytes UTF-8
Archivo	4.000.000 bytes
Contenedores anidados / valores de entrada	200 niveles / 100.000
Tipos inferidos / campos	10.000 / 20.000
Declaraciones generadas	2.000
Código de salida	2.000.000 unidades UTF-16 / 8.000.000 bytes
Tiempo de generación	15 segundos

Los ejemplos complejos pueden alcanzar otros límites de procesamiento antes. Si se supera un límite, no se entrega código parcial.

Copiar y descargar incluyen todo types.go, aunque la vista previa termine en 20.000 unidades UTF-16. El archivo usa UTF-8 sin BOM y un salto LF final. Si falla el portapapeles, puedes copiar el código completo manualmente.