JSON a Go Struct

¿Qué es la conversión de JSON a structs de Go?

La conversión de JSON a Go transforma datos JSON en definiciones de tipos Go que funcionan con el paquete encoding/json de la biblioteca estándar. Go es un lenguaje de tipado estático, por lo que cada campo JSON necesita un campo de struct correspondiente con el tipo correcto y un struct tag que le indica al serializador qué clave JSON mapear. Escribir estas definiciones a mano para respuestas de API grandes o muy anidadas es lento y fácil de equivocar.

El paquete encoding/json, incluido en la especificación de Go desde la versión 1.0, usa reflexión para hacer coincidir las claves JSON con los campos exportados de los structs. El matching es insensible a mayúsculas por defecto, pero los struct tags json explícitos son la práctica estándar porque eliminan la ambigüedad y permiten usar la convención PascalCase de Go mientras el JSON mantiene camelCase o snake_case. Un conversor automatiza todo esto: lee tu JSON, infiere los tipos Go a partir de los valores y produce definiciones de structs con los tags correctos.

El sistema de tipos de Go se mapea limpiamente a JSON. Las cadenas se convierten en string, los booleanos en bool, los enteros en int y los números de punto flotante en float64. Los objetos JSON anidados se convierten en structs con nombre separados, y los arrays en slices. El único caso especial es null: Go no tiene un tipo nullable universal, por lo que los valores null suelen convertirse en tipos puntero (*string, *int) o en interface{}. Un generador gestiona todo esto en milisegundos.

¿Por qué usar un conversor de JSON a Go?

Definir structs de Go a partir de JSON a mano implica contar llaves, adivinar tipos y reescribir tags cada vez que la API cambia. Un conversor elimina esa fricción.

Casos de uso de JSON a Go Struct

Mapeo de tipos JSON a Go

El paquete encoding/json sigue reglas específicas al mapear valores JSON a tipos Go. La tabla muestra el mapeo por defecto y las alternativas más comunes. La columna "Por defecto" muestra lo que producen la mayoría de los generadores. La columna "Alternativa" muestra tipos que podrías elegir según tus requisitos, como int64 para IDs grandes o tipos puntero para campos nullable.

Referencia de struct tags JSON en Go

Los struct tags controlan cómo encoding/json serializa y deserializa los campos. El tag json es con diferencia el más común, pero puedes combinarlo con otros tags (db, yaml, xml) en el mismo campo. La sintaxis del tag es una cadena delimitada por backticks tras el tipo del campo. A continuación se muestran las opciones del tag json que soporta encoding/json.

json.Unmarshal vs json.NewDecoder

Go ofrece dos formas de decodificar JSON: json.Unmarshal para slices de bytes y json.NewDecoder para flujos io.Reader. Ambos usan las mismas reglas de struct tags, pero difieren en cuándo usarlos.

Ejemplos de código

Estos ejemplos muestran cómo usar structs Go generados a partir de JSON en programas reales, y cómo generarlos desde otros lenguajes. Los ejemplos de Go usan encoding/json de la biblioteca estándar.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email"`
	IsActive bool     `json:"is_active"`
	Tags     []string `json:"tags"`
}

func main() {
	data := []byte(`{"id":1,"name":"Alice","email":"alice@example.com","is_active":true,"tags":["admin","editor"]}`)

	var user User
	if err := json.Unmarshal(data, &user); err != nil {
		panic(err)
	}
	fmt.Println(user.Name)  // → Alice
	fmt.Println(user.Tags)  // → [admin editor]
}

// JSON response from API — this is the shape you'd convert to Go:
const res = await fetch("https://api.example.com/users/1");
const user = await res.json();
// user → { "id": 1, "name": "Alice", "email": "alice@example.com" }

// Equivalent Go struct:
// type User struct {
//     ID    int    `json:"id"`
//     Name  string `json:"name"`
//     Email string `json:"email"`
// }

import json

def json_to_go(data: dict, name: str = "Root") -> str:
    lines = [f"type {name} struct {{"]
    type_map = {str: "string", int: "int", float: "float64", bool: "bool"}

    for key, value in data.items():
        go_type = type_map.get(type(value), "interface{}")
        field = key.title().replace("_", "")  # snake_case → PascalCase
        lines.append(f'\t{field} {go_type} `json:"{key}"`')
    lines.append("}")
    return "\n".join(lines)

data = json.loads('{"user_name": "Alice", "age": 30, "verified": true}')
print(json_to_go(data))
# type Root struct {
#     UserName string `json:"user_name"`
#     Age      int    `json:"age"`
#     Verified bool   `json:"verified"`
# }

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Event struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

func main() {
	stream := strings.NewReader(`{"type":"click","payload":"btn-1"}
{"type":"scroll","payload":"page-2"}`)

	dec := json.NewDecoder(stream)
	for dec.More() {
		var ev Event
		if err := dec.Decode(&ev); err != nil {
			break
		}
		fmt.Printf("%s: %s\n", ev.Type, ev.Payload)
	}
	// → click: btn-1
	// → scroll: page-2
}

Preguntas frecuentes