100 % local: tus datos nunca salen de tu navegador

JSON a Go — structs listas para tu archivo

Convierte una muestra JSON en structs de Go con etiquetas json. Las columnas salen alineadas como las dejaría gofmt: pegar no exige ninguna limpieza.

Instantáneo Privado Cero cookies

Entrada JSON

Salida Go

Qué hace esta herramienta

Una muestra JSON pasa a ser structs de Go, uno por objeto.

{ "id": 1, "firstName": "Ada", "address": { "city": "Paris" } }
type Root struct {
	Id        int     `json:"id"`
	FirstName string  `json:"firstName"`
	Address   Address `json:"address"`
}

type Address struct {
	City string `json:"city"`
}

Las columnas van alineadas como las alinea gofmt: nombre, tipo, tag. Nadie lee Go sin formatear, y pegar esto en un archivo y ejecutar gofmt no debería cambiar nada.

Esa alineación es reciente: los campos salían separados por un solo espacio. Una cosa pequeña, y aun así era una salida que no se parecía al lenguaje que dice hablar.

Los nombres se exportan, las claves viven en el tag

encoding/json ignora por completo los campos no exportados: un campo en minúscula no decodifica nada ni codifica nada, sin decir palabra. Por eso todos los campos van exportados —PascalCase, con una F delante cuando la clave empieza por dígito (2fa da F2fa)— y el tag lleva la clave original sin tocar.

Dos claves que producen el mismo nombre Go —user-name y userName— se mantienen separadas con un sufijo numerado. Los tags siguen siendo distintos: cada campo sigue correspondiendo a su propia clave.

omitempty omite más de lo que parece

La opción añade ,omitempty a cada tag. Se aplica solo al codificar y no distingue «ausente» de «cero»: 0, "", false, un slice vacío y un map nil desaparecen todos de la salida.

Está bien para un filtro opcional y es falso para una nota que puede valer cero legítimamente. Donde la diferencia importa, la respuesta habitual es un puntero —*int—, que codifica null para nil y un cero de verdad si no.

Los tipos y lo que una muestra no puede decir

  • Los enteros pasan a int, no a int64. En cualquier plataforma de 64 bits es lo mismo; un valor que la desborde falla ruidosamente al decodificar en vez de truncarse en silencio.
  • null y los valores desconocidos pasan a any. Un array vacío pasa a []any, uno mezclado también, salvo si mezcla enteros y flotantes: []float64 cubre entonces ambos.
  • Ningún campo es puntero y ninguno es opcional, porque una muestra no puede mostrarlo. Una clave que a veces falta es un *T que añades tú, y es lo primero que conviene comprobar contra una segunda carga.

Privado por diseño

Todo se ejecuta localmente en tu navegador con JavaScript. Tus datos nunca se suben a un servidor, lo que hace que la herramienta sea segura para contenido sensible y funcione sin conexión.

Preguntas frecuentes

¿Por qué los nombres de campo van en mayúscula inicial?
Porque `encoding/json` solo ve los campos exportados. Un `id` en minúscula se saltaría en ambos sentidos, en silencio: el struct compilaría, no decodificaría nada en ese campo y no codificaría nada desde él. El tag conserva la clave original, así que `Id int `json:"id"`` lee y escribe exactamente lo que tu documento trae.
¿Qué hace realmente la opción omitempty?
Añade `,omitempty` a cada tag, lo que deja fuera un valor cero **al codificar**. No cambia nada al decodificar y no distingue una clave ausente de un cero: `0`, `""`, `false` y un slice vacío desaparecen todos de la salida. Si un cero de verdad importa, un campo puntero es la respuesta habitual.
¿Mi campo debe llamarse `Id` o `ID`?
La guía de estilo de Go dice `ID`, y los linters también lo dirán. Esta herramienta escribe `Id`, derivado mecánicamente de la clave, porque renombrar las siglas supone mantener una lista —`ID`, `URL`, `API`, `HTTP`— y aplicarla a claves que nunca ha visto. El tag hace el renombrado inofensivo: es un retoque seguro para hacerlo tú.

Convertidores relacionados