JSON a Go Struct - Generador de Tipos Go en Línea

Preguntas Frecuentes

¿Qué es un convertidor de JSON a Go struct?

Un convertidor de JSON a Go struct es una herramienta que genera automáticamente definiciones de tipos struct de Go a partir de datos JSON. En lugar de escribir manualmente definiciones de struct con nombres de campo, tipos y etiquetas json struct, pega un objeto JSON de muestra y la herramienta infiere los tipos Go correctos para cada campo. Maneja objetos anidados como structs separados, arrays como slices y genera etiquetas struct `json:"field_name"` apropiadas para marshaling y unmarshaling.

¿Cómo genero structs de Go desde JSON?

Simplemente pegue sus datos JSON en el campo de entrada del lado izquierdo. La herramienta generará instantáneamente definiciones de struct de Go en el panel de salida de la derecha. Puede personalizar la salida configurando el nombre del struct raíz, alternando omitempty en las etiquetas struct, eligiendo entre structs anidados en línea o separados, y habilitando tipos puntero para campos anulables. Una vez satisfecho, haga clic en 'Copiar' para copiar el código generado al portapapeles.

¿Qué hace omitempty en las etiquetas struct de Go?

La opción `omitempty` en una etiqueta json struct indica al codificador JSON de Go que omita el campo de la salida si tiene un valor cero (cadena vacía, 0, false, puntero nil, slice vacío o mapa vacío). Por ejemplo, un campo etiquetado `json:"name,omitempty"` no aparecerá en la salida JSON si el nombre es una cadena vacía. Esto es útil para solicitudes API donde solo desea enviar campos que se han establecido explícitamente.

¿Debo usar structs en línea o separados?

Los structs separados (por defecto) crean un tipo nombrado para cada objeto anidado, haciéndolos reutilizables en todo su código. Por ejemplo, si su JSON tiene un objeto 'user' con un subobjeto 'address', la herramienta crea tanto un struct 'User' como un struct 'Address'. Los structs en línea incorporan la definición de tipo directamente, lo cual es más compacto pero no se puede reutilizar. Use structs separados para código de producción y structs en línea para prototipos rápidos o scripts únicos.

¿Están seguros mis datos JSON al usar esta herramienta?

Sí, completamente. Esta herramienta procesa todo en su navegador usando JavaScript del lado del cliente. Sus datos JSON nunca salen de su computadora - no hay cargas al servidor, no hay llamadas API y no hay almacenamiento de datos. Esto lo hace seguro para usar con respuestas API sensibles, esquemas de datos propietarios, contratos de microservicios internos y archivos de configuración confidenciales.

¿Cómo maneja la herramienta las convenciones de nomenclatura de Go?

La herramienta sigue las convenciones oficiales de nomenclatura de Go de Effective Go. Los nombres de campo JSON se convierten a PascalCase para campos struct exportados (p.ej., 'user_name' se convierte en 'UserName'). Las abreviaturas comunes se capitalizan correctamente: 'id' se convierte en 'ID', 'url' en 'URL', 'http' en 'HTTP', 'api' en 'API'. La clave JSON original se preserva en la etiqueta struct para el marshaling JSON correcto.

¿Cuándo debo usar tipos puntero para campos anulables?

Use tipos puntero cuando necesite distinguir entre un valor cero y un valor ausente/null. Por ejemplo, sin punteros, un campo 'age' faltante en JSON se desmarshala a 0 (el valor cero para int), haciendo imposible saber si la edad era realmente 0 o simplemente no se proporcionó. Con tipos puntero (*int), un campo faltante se convierte en nil. Habilite la opción 'Tipos puntero' cuando trabaje con APIs que usan null para indicar datos opcionales o ausentes.

Ejemplos de Código

// JSON to Go struct generator
function jsonToGoStruct(json, rootName = 'AutoGenerated') {
  const structs = [];
  const abbreviations = new Set([
    'id', 'url', 'http', 'api', 'html', 'json', 'xml', 'sql',
    'ssh', 'tcp', 'udp', 'ip', 'dns', 'uid', 'uuid', 'cpu',
  ]);

  function toGoName(key) {
    return key.split(/[-_\s]+/).map(word => {
      if (abbreviations.has(word.toLowerCase())) {
        return word.toUpperCase();
      }
      return word.charAt(0).toUpperCase() + word.slice(1);
    }).join('');
  }

  function inferType(value, name) {
    if (value === null) return 'interface{}';
    if (typeof value === 'boolean') return 'bool';
    if (typeof value === 'number') {
      return Number.isInteger(value) ? 'int' : 'float64';
    }
    if (typeof value === 'string') return 'string';
    if (Array.isArray(value)) {
      if (value.length === 0) return '[]interface{}';
      return '[]' + inferType(value[0], name + 'Item');
    }
    if (typeof value === 'object') {
      const structName = toGoName(name);
      const fields = Object.entries(value).map(([key, val]) => {
        const goType = inferType(val, key);
        const goName = toGoName(key);
        return `\t${goName} ${goType} \`json:"${key}"\``;
      });
      structs.push(`type ${structName} struct {\n${fields.join('\n')}\n}`);
      return structName;
    }
    return 'interface{}';
  }

  const parsed = JSON.parse(json);
  inferType(parsed, rootName);
  return structs.reverse().join('\n\n');
}

// Example usage
const json = '{"user_id": 1, "user_name": "alice", "address": {"city": "NYC"}}';
console.log(jsonToGoStruct(json));
// Output:
// type Address struct {
// 	City string `json:"city"`
// }
//
// type AutoGenerated struct {
// 	UserID   int     `json:"user_id"`
// 	UserName string  `json:"user_name"`
// 	Address  Address `json:"address"`
// }