Codificar y decodificar JSON en Go con Marshal y Unmarshal

Codificar y decodificar JSON con Go/GoLang

1 comentario / Go y Golang, javascript, web / Por

JSON y Go

En este post voy a explicar cómo codificar y decodificar el formato JSON (JavaScript Object Notation) usando el lenguaje de programación Go, también conocido como Golang.

Para hacerlo no necesitamos librerías externas ni paquetes extraños; solamente a encoding/json con las funciones Marshal y Unmarshal que nos permitirán trabajar con structs, arreglos, cadenas y todos los tipos de datos.

Codificar y decodificar JSON en Go con Marshal y Unmarshal
Codificar y decodificar JSON en Go con Marshal y Unmarshal

Nota: esto ya lo hicimos con PHP, Java y JavaScript.

Convertir a JSON con Go

Para codificar a JSON usamos la función json.Marshal. Esta función recibe el valor que vamos a codificar, el cual es de tipo interface{} es decir, de cualquier tipo (cadenas, structs, enteros).

Devuelve un arreglo de bytes []byte y un posible error. Para convertir el arreglo de bytes a cadena simplemente usamos la función string(). Ya veremos el ejemplo de código:

package main
/*
	Codificar a JSON con Go

	@author parzibyte
*/
import (
	"encoding/json"
	"fmt"
)

func main() {
	// Cadenas
	nombre := "Luis Cabrera Benito"
	nombreComoJson, err := json.Marshal(nombre)
	if err != nil {
		fmt.Printf("Error codificando nombre: %v", err)
	} else {
		fmt.Println(string(nombreComoJson))
	}

	// Números
	edad := 21
	edadComoJson, err := json.Marshal(edad)
	if err != nil {
		fmt.Printf("Error codificando edad: %v", err)
	} else {
		fmt.Println(string(edadComoJson))
	}

	// Arreglos de todo tipo. En este caso de cadena...
	videojuegos := []string{"Resident Evil", "Super Mario Bros", "Cuphead", "Halo"}
	videojuegosComoJson, err := json.Marshal(videojuegos)
	if err != nil{
		fmt.Printf("Error codificando videojuegos: %v", err)
	}else{
		fmt.Println(string(videojuegosComoJson))
	}

	// Structs. Definimos unos para ver que soporta profundidad

	type Raza struct {
		Nombre, Pais string
	}

	type Mascota struct {
		Nombre string
		Edad   int
		Raza   Raza
		Amigos []string // Arreglo de strings
	}

	// Creamos algunos y los codificamos
	raza := Raza{"Caniche", "Francia"}
	amigos := []string{"Bichi", "Snowball", "Coqueta", "Cuco", "Golondrino"}
	mascota := Mascota{"Maggie", 3, raza, amigos}
	mascotaComoJson, err := json.Marshal(mascota)
	if err != nil {
		fmt.Printf("Error codificando mascota: %v", err)
	} else {
		fmt.Println(string(mascotaComoJson))
	}
}

En el código estamos codificando varios tipos de datos. Como lo dije, se devuelve un posible error que, en caso de que todo sea exitoso, estará en nil.

Dentro del código también puse un ejemplo de cómo codificar un struct, que es algo así como una Clase en Go.

Resumiendo:

  1. Para codificar llama a json.Marshal, el cual devuelve un arreglo de bytes que puedes convertir a cadena con string().
  2. El método acepta todos los tipos de datos, o bueno, casi todos. También acepta mapas. Recuerda que puedes poner un struct dentro de otro struct, así como arreglos y todo tipo de datos

Decodificar JSON con Go

Para hacer el proceso inverso llamamos a json.Unmarshal que recibe dos argumentos y devuelve un error que puede ser nil.

El primer argumento es un arreglo de bytes (podemos convertir un string a arreglo de bytes con []byte()) y el segundo es el apuntador a una variable de cualquier tipo, en donde serán almacenados los datos decodificados.

Recordemos que el apuntador (bueno, la dirección de memoria que apunta a la variable) se toma con el ampersand &. Para decodificar, por lo tanto, se necesita definir la variable antes de llamar a json.Unmarshal. Veremos los ejemplos.

package main

/*
	Decodificar JSON con Go

	@author parzibyte
*/
import (
	"encoding/json"
	"fmt"
)

func main() {
	// Nota: Convertimos a []byte la cadena porque Unmarshal lo pide

	nombreComoJson := []byte(`"Luis Cabrera Benito"`)
	// Definir variable
	var nombre string
	// Decodificar. No olvides pasar LA DIRECCIÓN en lugar de la variable en sí
	err := json.Unmarshal(nombreComoJson, &nombre)
	if err != nil {
		fmt.Printf("Error decodificando: %v\n", err)
	} else {
		fmt.Printf("Nombre: %s\n", nombre)
	}

	// Arreglo como JSON, este podría venir de un formulario, petición o lo que sea

	arregloComoJson := []byte(`["Resident Evil","Super Mario Bros","Cuphead","Halo"]`)
	// Debemos definir la variable que alojará los valores decodificados
	arreglo := []string{}
	// Y ahora decodificamos pasando el apuntador
	err = json.Unmarshal(arregloComoJson, &arreglo)
	if err != nil {
		fmt.Printf("Error decodificando: %v\n", err)
	} else {
		fmt.Println("En posición 0: ", arreglo[0]) // Resident Evil
	}

	// Otra vez los structs
	type Raza struct {
		Nombre, Pais string
	}

	type Mascota struct {
		Nombre string
		Edad   int
		Raza   Raza
		Amigos []string // Arreglo de strings
	}

	// Vamos a probar...
	mascotaComoJson := []byte(`{"Nombre":"Maggie","Edad":3,"Raza":{"Nombre":"Caniche","Pais":"Francia"},"Amigos":["Bichi","Snowball","Coqueta","Cuco","Golondrino"]}`)

	// Recuerda, primero se define la variable
	var mascota Mascota

	// Y luego se manda su dirección de memoria
	err = json.Unmarshal(mascotaComoJson, &mascota)
	if err != nil {
		fmt.Printf("Error decodificando: %v\n", err)
	} else {
		// Listo. Ahora podemos imprimir
		fmt.Printf("El nombre: %s\n", mascota.Nombre)
		fmt.Printf("País de Raza: %s\n", mascota.Raza.Pais)
		fmt.Printf("Primer amigo: %v\n", mascota.Amigos[0])
	}
}

Tal vez se vea algo raro la utilización de backticks pero es para poner los datos como JSON codificados sin tener que escapar las comillas. En la vida real ese JSON podría venir de una petición, ser leído de un archivo o cosas de esas.

Resumiendo:

  1. Define la variable (de cualquier tipo, pero que coincida con el JSON) en donde pondrás los datos decodificados.
  2. Llama a json.Unmarshal, pásale la cadena JSON como un arreglo de bytes y el apuntador a la variable, maneja el posible error y listo: si todo sale bien podrás acceder a la variable

Usos de JSON en Go

Los usos son los mismos que en otros lenguajes de programación, pero específicamente hablando de Go puedo decir que la API de Sublime POS 3 utiliza JSON para el intercambio de datos.

Probar ejercicios

Puedes descargar los ejercicios que acabamos de ver. Si los descargas recuerda instalar y configurar Go.

He escrito más tutoriales sobre Go, por favor míralos.

Como referencia dejo un enlace al blog oficial de Go.

Estoy aquí para ayudarte 🤝💻

Estoy aquí para ayudarte en todo lo que necesites. Si requieres alguna modificación en lo presentado en este post, deseas asistencia con tu tarea, proyecto o precisas desarrollar un software a medida, no dudes en contactarme. Estoy comprometido a brindarte el apoyo necesario para que logres tus objetivos. Mi correo es parzibyte(arroba)gmail.com, estoy como@parzibyte en Telegram o en mi página de contacto

No te pierdas ninguno de mis posts 🚀🔔

Suscríbete a mi canal de Telegram para recibir una notificación cuando escriba un nuevo tutorial de programación.

1 comentario en “Codificar y decodificar JSON con Go/GoLang”

  1. Pingback: Petición POST, GET, PUT y DELETE en Go con net/http - Parzibyte's blog

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *