Generadores de código · 5 minutos de lectura

JSON to Go: estructuras que se descomponen en el primer

Go te hace escribir la forma del JSON que estás decodificando y el compilador te obliga a cumplirla. Una conversión de JSON a Go a partir de una respuesta real elimina tanto la escritura como las conjeturas: los nombres de los campos, las etiquetas `json` y los tipos anidados llegan correctos y puede ir directamente a la parte del programa que realmente hace algo.

Actualizado 12 de octubre de 2026

La forma generada

Un convertidor convierte cada objeto JSON en una estructura, cada matriz en un segmento e infiere un tipo Go por valor. Los objetos anidados se convierten en tipos con nombre en lugar de blobs anónimos, lo que mantiene legible la firma del código de decodificación:

                type Container struct {
  Name  string `json:"name"`
  Image string `json:"image"`
  Ports []struct {
    ContainerPort int `json:"containerPort"`
  } `json:"ports"`
}

Las etiquetas `json` son la parte importante. El decodificador de Go no distingue entre mayúsculas y minúsculas al hacer coincidir nombres de campos, pero `containerPort` y `ContainerPort` no se alinean sin una etiqueta, y cualquier clave que no sea un identificador de Go válido (`app.kubernetes.io/name`, por ejemplo) no puede coincidir sin una.

Números, nulos y las dos trampas clásicas

Números: la inferencia produce `int` para valores enteros, pero JSON no tiene ningún tipo de número entero. Un campo que hoy es `3` puede ser `3.5` mañana, por lo que las identificaciones y el dinero están más seguros como `float64`, `string` o `json.Number`, según sus necesidades.
Nulos: una clave que puede ser `null` debe ser un puntero (`*string`) para poder distinguir “ausente” de “vacío”.
Marcas de tiempo: una cadena RFC 3339 se decodifica limpiamente en `time.Time`; un número de época de Unix no lo hace, así que manténgalos como `int64` y conviértalos explícitamente.
Campos desconocidos: `json.Decoder` ignora los extras de forma predeterminada; usa `DisallowUnknownFields` cuando prefieras fallar en voz alta.

Genera a partir de dos o tres respuestas cuando puedas. Los campos que a veces faltan se convierten en indicadores, y esa decisión es mucho más fácil de tomar a partir de evidencia que de memoria.

De la estructura al código de trabajo

Con las estructuras en su lugar, la decodificación es de tres líneas y el compilador impone las rutas de acceso desde allí. Un patrón común es decodificar en la estructura generada y luego asignarlo a su tipo de dominio para que la forma JSON pueda cambiar sin afectar la aplicación. Etiquete el archivo generado con el punto final del que procede y regenere cuando cambie la respuesta en lugar de editarlo a mano: el código generado editado a mano es la versión que nadie se atreve a regenerar más tarde.

Generar localmente

Las cargas útiles a partir de las cuales vale la pena generar estructuras Go suelen ser respuestas API reales, y las respuestas reales contienen tokens y datos de clientes. Una conversión de JSON a Go basada en navegador mantiene la carga útil en la pestaña (sin carga, sin preguntas de retención), lo que hace que la generación a partir de datos de producción sea un paso normal en lugar de una excepción de política.

JSON para ir — preguntas frecuentes

¿Por qué mis estructuras Go no decodifican JSON?

Los nombres de los campos en JSON rara vez coinciden exactamente con los nombres exportados de Go, por lo que la estructura necesita etiquetas `json`. Regenere con las etiquetas habilitadas, confirme la ortografía de las claves, incluida la puntuación, y verifique si el decodificador debe permitir campos desconocidos.

¿Los campos numéricos generados deberían ser int o float64?

Utilice `float64` (o `json.Number` cuando la precisión sea importante) para cualquier cosa que no sea un API externo, porque JSON no distingue números enteros de decimales. Reserva `int` para los valores que controlas de principio a fin.

¿Cómo manejo un campo que a veces es nulo?

Conviértalo en un tipo de puntero como `*string`, que codifica tanto “clave ausente” como “clave presente con valor nulo” y al mismo tiempo le permite verificar un valor real. Los campos que no son punteros se convierten silenciosamente en valores cero.