Trabajo con JSON en Go: análisis y serialización de datos

Introducción al trabajo con JSON en Go

JSON (JavaScript Object Notation) es uno de los formatos de intercambio de datos más populares en aplicaciones web modernas, microservicios y APIs. El lenguaje Go (Golang) ofrece soporte integrado y potente para trabajar con JSON a través del paquete encoding/json. Este paquete permite convertir fácilmente datos entre estructuras de Go y cadenas JSON, y viceversa.

En este artículo, analizaremos en detalle cómo realizar el análisis (deserialización) y la serialización de JSON en Go. Aprenderá a trabajar con estructuras simples y anidadas, manejar errores y personalizar nombres de campos. El material será útil tanto para principiantes como para desarrolladores experimentados que deseen sistematizar sus conocimientos.

Fundamentos de la serialización (Marshal) en Go

Conversión de una estructura de Go a JSON

La serialización es el proceso de convertir un objeto de Go (por ejemplo, una estructura o un slice) en una cadena JSON. Para esto se utiliza la función json.Marshal(). Veamos un ejemplo sencillo:

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string    Age   int    Email string}

func main() {    user := User{        Name:  "Iván Petrov",        Age:   30,        Email: "ivan@example.com",    }

    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Println("Error de serialización:", err)        return    }

    fmt.Println(string(jsonData))}

Salida del programa:

{"Name":"Iván Petrov","Age":30,"Email":"ivan@example.com"}

Tenga en cuenta: los nombres de los campos en JSON coinciden con los nombres de los campos de la estructura. Pero a menudo es necesario cambiarlos, por ejemplo, para que estén en estilo camelCase. Para esto se utilizan tags de estructura.

Uso de tags para personalizar JSON

Los tags de estructura permiten especificar cómo se serializará un campo. Agreguemos tags a nuestro ejemplo:

type User struct {    Name  string `json:"name"`    Age   int    `json:"age"`    Email string `json:"email,omitempty"`}

Ahora la salida será así:

{"name":"Iván Petrov","age":30,"email":"ivan@example.com"}

Opciones clave de los tags:

• json:"field_name" — establece el nombre del campo en JSON.
• omitempty — excluye el campo del JSON si tiene un valor cero (cadena vacía, 0, false, nil).
• - — ignora completamente el campo durante la serialización/deserialización.

Serialización de slices y maps

El paquete encoding/json funciona muy bien no solo con estructuras, sino también con slices, maps y tipos simples:

// Slice de estructurasusers := []User{    {Name: "Ana", Age: 25},    {Name: "Boris", Age: 35},}jsonUsers, _ := json.Marshal(users)fmt.Println(string(jsonUsers))// Salida: [{"name":"Ana","age":25},{"name":"Boris","age":35}]

// Mapdata := map[string]interface{}{    "status": "ok",    "count":  42,}jsonMap, _ := json.Marshal(data)fmt.Println(string(jsonMap))// Salida: {"count":42,"status":"ok"}

Análisis de JSON (Unmarshal) en Go

Análisis básico en una estructura

La deserialización (análisis) es el proceso inverso: convertir una cadena JSON en un objeto de Go. Se utiliza la función json.Unmarshal(). Importante: la estructura de destino debe estar exportada (campos con mayúscula inicial) o tener los tags correspondientes.

jsonString := `{"name":"María","age":28,"email":"maria@example.com"}`

var user Usererr := json.Unmarshal([]byte(jsonString), &user)if err != nil {    fmt.Println("Error de análisis:", err)    return}

fmt.Printf("Nombre: %s, Edad: %d", user.Name, user.Age)// Salida: Nombre: María, Edad: 28

Análisis de estructuras anidadas

JSON a menudo contiene objetos anidados.