Trabajo con JSON en Go: análisis y serialización en la práctica

Trabajo con JSON en Go: análisis y serialización en la práctica

JSON (JavaScript Object Notation) es uno de los formatos de intercambio de datos más populares en el desarrollo web. En el lenguaje Go (Golang), el trabajo con JSON se implementa a través del paquete estándar encoding/json, que proporciona herramientas potentes y convenientes para la serialización (conversión de estructuras de datos a JSON) y la deserialización (análisis de JSON a estructuras de Go). En este artículo, analizaremos en detalle cómo trabajar con JSON en Go con ejemplos prácticos.

Fundamentos: serialización de estructuras a JSON

La forma más común de trabajar con JSON en Go es usar estructuras con etiquetas. Las etiquetas permiten especificar los nombres de los campos en JSON, que pueden diferir de los nombres de los campos en Go. Veamos un ejemplo básico de serialización:

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"`}

func main() {    user := User{        ID:       1,        Name:     "Iván Petrov",        Email:    "ivan@example.com",        IsActive: true,    }

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

    fmt.Println(string(jsonData))    // Salida: {"id":1,"name":"Iván Petrov","email":"ivan@example.com","is_active":true}}

Tenga en cuenta: usamos etiquetas json:"nombre_del_campo" para controlar los nombres de las claves en JSON. Esto es especialmente útil cuando se deben seguir ciertos estándares de nomenclatura (por ejemplo, snake_case en JSON y CamelCase en Go).

Análisis de JSON en estructuras de Go

La deserialización (análisis) de datos JSON en estructuras se realiza con la función json.Unmarshal. Es importante que la estructura coincida con la estructura del objeto JSON. Continuemos con nuestro ejemplo:

func main() {    jsonString := `{"id":2,"name":"María Sidorova","email":"maria@example.com","is_active":false}`

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

    fmt.Printf("ID: %d, Nombre: %s, Email: %s, Activo: %t",        user.ID, user.Name, user.Email, user.IsActive)    // Salida: ID: 2, Nombre: María Sidorova, Email: maria@example.com, Activo: false}

Importante: A la función json.Unmarshal siempre se le pasa un puntero a la estructura (&user), de lo contrario los cambios no se guardarán.

Trabajo con estructuras anidadas y arreglos

Los datos JSON reales a menudo contienen objetos anidados y arreglos. Go permite manejar elegantemente estos casos con estructuras anidadas:

type Address struct {    City    string `json:"city"`    Street  string `json:"street"`    ZipCode string `json:"zip_code"`}

type Employee struct {    ID      int      `json:"id"`    Name    string   `json:"name"`    Skills  []string `json:"skills"`    Address Address  `json:"address"`}

func main() {    jsonData := `{        "id": 101,        "name": "Alexéi Ivanov",        "skills": ["Go", "Python", "Docker"],        "address": {            "city": "Moscú",            "street": "Tverskaya, 10",            "zip_code": "101000"        }    }`

    var emp Employee    err := json.Unmarshal([]byte(jsonData), &emp)    if err != nil {        fmt.Println("Error:", err)        return    }

    fmt.Printf("Empleado: %s, Ciudad: %s, Habilidades: %v",        emp.Name, emp.Address.City, emp.Skills)    // Salida: Empleado: Alexéi Ivanov, Ciudad: Moscú, Habilidades: [Go Python Docker]}

Para arreglos en Go se usan slices ([]string), y para objetos anidados, estructuras separadas. Al analizar un arreglo JSON de objetos, se