JSON con Marshal y Unmarshal en Go

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:06

JSON con Marshal y Unmarshal en Go

Curso de Go

Clase 25 de 28

Clase 25 / 28

Recursos

Trabajar con JSON en Go es una de las habilidades base para conectar APIs, mover datos entre sistemas y construir aplicaciones reales. Aquí aprendes a convertir un objeto en JSON y un JSON en objeto usando los métodos Marshal y Unmarshal del paquete encoding/json, con ejemplos prácticos que puedes replicar.

Cómo organizar el proyecto antes de codificar JSON en Go

Antes de escribir una sola línea, conviene preparar la estructura de carpetas. En Go existe una regla silenciosa pero estricta: no debes tener dos archivos main.go dentro de la misma carpeta, porque el compilador lo interpreta como un conflicto.

La solución es separar cada ejercicio en su propio directorio. Crea una carpeta json y dentro dos subcarpetas:

encode, donde vivirá el ejemplo que convierte un objeto en JSON.
decode, donde vivirá el ejemplo que convierte un JSON en objeto.
Cada una con su propio main.go.

Esta separación mantiene una relación uno a uno entre carpeta y archivo ejecutable, y evita errores al compilar.

¿Por qué Go no permite dos main.go en la misma carpeta? Porque cada paquete main define un único punto de entrada. Si hay dos, el compilador no sabe cuál ejecutar.

Cómo convertir un struct en JSON con Marshal

El proceso de encoding toma una estructura de Go y la transforma en una cadena con formato JSON. Para esto necesitas dos paquetes: fmt para imprimir y encoding/json para la conversión.

El truco está en la definición del struct. Junto a cada campo puedes agregar una tag entre acentos graves que indica cómo se llamará esa propiedad en el JSON final. Esto resuelve un problema común: que tus variables en Go usen una convención (mayúscula inicial, nombres en español) y el JSON requiera otra (minúsculas, nombres en inglés).

go type Persona struct { Nombre string json:"name" Edad int json:"age" Email string json:"email" }

Una vez declarada la estructura, creas una instancia con datos y la pasas a json.Marshal. Este método devuelve dos valores: el resultado en bytes y un error.

go p := Persona{Nombre: "Amin Espinosa", Edad: 40, Email: "aminespinosa@platzi.com"} jsonData, err := json.Marshal(p) if err == nil { fmt.Println("Tu archivo JSON es:", string(jsonData)) }

Validar que err sea nil es obligatorio. Si la conversión falla, normalmente es porque algún campo del struct no es compatible con el formato JSON esperado.

Por qué convertir bytes a string al imprimir

Marshal devuelve un slice de bytes, no una cadena directamente legible. Para verlo en consola con un formato humano, lo conviertes con string(jsonData). Sin esa conversión verías una secuencia de números ASCII en lugar del JSON con llaves y comillas.

Cómo convertir un JSON en struct con Unmarshal

El camino inverso se llama decoding y usa el método json.Unmarshal. La nemotecnia es directa: Marshal codifica, Unmarshal decodifica.

Aquí el reto inicial es escribir el JSON dentro del código Go. Si usas comillas dobles para abrir la cadena, las comillas internas del JSON rompen la sintaxis. La solución es delimitar la cadena con acentos graves, que en Go funcionan como raw string literals y permiten incluir comillas dobles sin escapar nada.

go jsonString := {"name":"Amin Espinosa","age":40,"email":"aminespinosa@platzi.com"} var p Persona err := json.Unmarshal([]byte(jsonString), &p) if err != nil { fmt.Println("Hubo un problema:", err) } fmt.Println(p.Nombre, p.Edad, p.Email)

Fíjate en dos detalles clave:

Unmarshal recibe un slice de bytes, por eso conviertes el string con []byte(...).
Pasas la dirección de memoria del struct con &p, porque Unmarshal necesita modificar la variable original.

¿Cuál es la diferencia entre Marshal y Unmarshal en Go? Marshal toma un objeto Go y lo convierte en JSON. Unmarshal toma un JSON y rellena un objeto Go con esos datos. Uno serializa, el otro deserializa.

Cómo manejar errores en la conversión

Tanto Marshal como Unmarshal devuelven un valor de tipo error. Ignorarlo es una mala práctica, porque enmascara problemas como campos mal nombrados, tipos incompatibles o JSON mal formado. La verificación if err != nil debe acompañar siempre estas operaciones.

Habilidades y conceptos que practicas en este flujo

Este ejercicio entrena varias capacidades técnicas que vas a reutilizar en cualquier proyecto con APIs:

Definición de struct tags con acentos graves para mapear nombres entre Go y JSON [1:30].
Uso del paquete encoding/json de la librería estándar [0:55].
Patrón de manejo de errores con valor de retorno doble [3:20].
Conversión entre []byte y string para imprimir resultados [4:10].
Uso de raw string literals con backticks para JSON embebido [6:15].
Paso por referencia con & para que Unmarshal modifique el struct [7:00].

Dominar estos seis puntos te deja listo para consumir cualquier API REST en Go sin depender de librerías externas. ¿Ya probaste convertir tu propio struct en JSON? Cuéntame en los comentarios qué estructura usaste.

Samuel Soto Hoyos

Hace un año

Para manejar JSON de forma efectiva en Go, es fundamental comprender y aplicar las características del lenguaje y de su librería estándar. Basándonos en las fuentes, aquí te presento las buenas prácticas clave:

Uso del Paquete Estándar encoding/json: Go proporciona un paquete incorporado, encoding/json, que implementa la codificación y decodificación de JSON. Es la herramienta principal y recomendada para trabajar con JSON en Go.
Manejo de Serialización/Deserialización Personalizada (json.Marshaler):
- Si la serialización o deserialización predeterminada de Go para un tipo no satisface tus necesidades, puedes personalizarla implementando la interfaz json.Marshaler (y/o json.Unmarshaler). Cuando el codificador JSON encuentra un valor que implementa esta interfaz, invoca el método de serialización del valor para convertirlo a JSON en lugar de usar la conversión estándar.
- Verificación en Tiempo de Compilación: Para garantizar que tu tipo implementa correctamente la interfaz json.Marshaler, puedes usar una declaración global con el identificador en blanco (_). Esto fuerza una verificación en tiempo de compilación, asegurando que tu implementación es correcta y alertándote si la interfaz cambia en futuras versiones:var _ json.Marshaler = (*MiTipo)(nil) Esta declaración existe solo para la verificación de tipos y no crea una variable. Se recomienda para casos donde no hay conversiones estáticas que ya verifiquen la implementación de la interfaz.
Control de Valores Cero con omitzero (Go 1.24+):
- Una característica importante introducida en Go 1.24 para el paquete JSON es la opción omitzero. Esta opción mejora el control sobre cómo tus objetos son serializados a JSON.
- Resuelve errores comunes y comportamientos inesperados que surgían al tratar con los "valores cero" de Go, como structs vacíos o valores time.Time no inicializados. Su uso proporciona mayor control sobre la serialización y ayuda a evitar posibles fuentes de error y confusión.
Concurrencia Segura:
- Aunque no es exclusivo del manejo de JSON, cualquier interacción con datos que se comparten entre goroutines (por ejemplo, estructuras de datos que se serializarán o deserializarán) debe seguir el principio de concurrencia de Go: "No comunicarse compartiendo memoria; en su lugar, compartir memoria comunicándose".
- Esto implica usar operaciones de canal u otras primitivas de sincronización (como las del paquete sync o sync/atomic) para proteger los datos. Ignorar esto puede llevar a condiciones de carrera (data race), que Go puede detectar y reportar en tiempo de ejecución, incluso terminando el programa. El uso de herramientas como el detector de carreras (go build -race) es fundamental para identificar estos problemas.
Diseño Idiomático y Clara Estructura de Código:
- Go fomenta la escritura de código claro, performante e idiomático. Si bien Effective Go (una guía clave de buenas prácticas) no se ha actualizado significativamente desde 2009 y no cubre los detalles de las librerías modernas de Go, sus principios generales de diseño siguen siendo válidos.
- Utiliza gofmt para asegurar un estilo de formato consistente en todo tu código, lo que mejora la legibilidad y reduce las discusiones sobre estilo.
- La filosofía de Go se centra en la simplicidad, la composición de componentes independientes y el soporte para la concurrencia y la recolección de basura, lo que facilita la construcción de sistemas fiables y escalables. Estos principios también se aplican al diseño de estructuras de datos que interactúan con JSON.

Al seguir estas prácticas, podrás escribir código Go robusto, legible y eficiente al trabajar con JSON.

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

JSON con Marshal y Unmarshal en Go