Go y Golang

Codificar y decodificar JSON con Go/GoLang

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

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.
parzibyte

Programador freelancer listo para trabajar contigo. Aplicaciones web, móviles y de escritorio. PHP, Java, Go, Python, JavaScript, Kotlin y más :) https://parzibyte.me/blog/software-creado-por-parzibyte/

Ver comentarios

Entradas recientes

Desplegar PWA creada con Vue 3, Vite y SQLite3 en Apache

Ya te enseñé cómo convertir una aplicación web de Vue 3 en una PWA. Al…

8 horas hace

Arquitectura para wasm con Go, Vue 3, Pinia y Vite

En este artículo voy a documentar la arquitectura que yo utilizo al trabajar con WebAssembly…

8 horas hace

Vue 3 y Vite: crear PWA (Progressive Web App)

En un artículo anterior te enseñé a crear un PWA. Al final, cualquier aplicación que…

8 horas hace

Errores de Comlink y algunas soluciones

Al usar Comlink para trabajar con los workers usando JavaScript me han aparecido algunos errores…

9 horas hace

Esperar promesa para inicializar Store de Pinia con Vue 3

En este artículo te voy a enseñar cómo usar un "top level await" esperando a…

9 horas hace

Solución: Apache – Server unable to read htaccess file

Ayer estaba editando unos archivos que son servidos con el servidor Apache y al visitarlos…

23 horas hace

Esta web usa cookies.