encoding/json con Structs

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 76 de 107.

El paquete encoding/json te permite convertir structs de Go a JSON y viceversa. Esto es esencial para APIs, archivos de configuración y almacenamiento de datos. Las etiquetas de struct controlan cómo los campos se mapean a las claves JSON.

Para convertir un struct a JSON, usa json.Marshal:

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

func main() {
    user := User{Name: "Alice", Email: "alice@example.com", Age: 30}
    data, _ := json.Marshal(user)
    fmt.Println(string(data))
    // {"name":"Alice","email":"alice@example.com","age":30}
}

Las etiquetas de estructura (struct tags) como `json:"name"` especifican los nombres de las claves JSON. Sin etiquetas, Go utiliza el nombre del campo directamente. Solo los campos exportados (con mayúscula inicial) se incluyen en la salida JSON.

Para convertir JSON de nuevo a una estructura, utiliza json.Unmarshal:

jsonStr := `{"name":"Bob","email":"bob@example.com","age":25}`
var user User
json.Unmarshal([]byte(jsonStr), &user)
fmt.Println(user.Name)  // Bob

Las opciones de etiquetas comunes incluyen omitempty para omitir valores cero y - para ignorar un campo por completo:

type Product struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Price    float64 `json:"price,omitempty"`
    Internal string `json:"-"`
}

Con omitempty, si Price es cero, no aparecerá en el JSON. El campo Internal nunca se incluye, independientemente de su valor.

Desafío

Fácil

¡Vamos a construir un sistema de catálogo de películas que convierta entre structs de Go y JSON! Practicarás el marshaling de structs a JSON y el unmarshaling de JSON de vuelta a structs, utilizando etiquetas de struct para controlar los nombres de los campos JSON.

Organizarás tu código en dos archivos:

movie.go: Define tu modelo de datos de película con las etiquetas JSON adecuadas.
Crea un struct Movie con los siguientes campos y mapeos JSON:
- Title (string) se mapea a "title"
- Director (string) se mapea a "director"
- Year (int) se mapea a "year"
- Rating (float64) se mapea a "rating" con omitempty para que las películas sin calificación no muestren un campo de calificación
- InternalID (string) debe ser excluido de JSON por completo usando "-"
Crea una función ToJSON(m Movie) string que convierta una Movie en una cadena JSON. También crea FromJSON(jsonStr string) Movie que analice una cadena JSON de vuelta a un struct Movie.
main.go: Demuestra la conversión JSON en ambas direcciones.
Lee un tipo de operación (encode o decode).

Para encode: Lee los detalles de la película (título, director, año, calificación) en líneas separadas. Crea una Movie con un InternalID de "internal-123", conviértela a JSON e imprime el resultado.

Para decode: Lee una cadena JSON, conviértela a un struct Movie e imprime los detalles de la película en este formato:
```
Title: [title]
Director: [director]
Year: [year]
Rating: [rating]
```
Muestra la calificación con un decimal. Si la calificación es 0 (no presente en el JSON), imprime Rating: N/A en su lugar.

Se proporcionarán las siguientes entradas:

Línea 1: Tipo de operación (encode o decode)
Para encode: título, director, año, calificación (cuatro líneas)
Para decode: una cadena JSON (una línea)

Por ejemplo, dado:

encode
Inception
Christopher Nolan
2010
8.8

Tu salida debería ser:

{"title":"Inception","director":"Christopher Nolan","year":2010,"rating":8.8}

Observa que InternalID no aparece en la salida debido a la etiqueta "-".

Y dado:

encode
The Matrix
Wachowskis
1999
0

Tu salida debería ser:

{"title":"The Matrix","director":"Wachowskis","year":1999}

Observa que rating se omite porque es cero y tiene omitempty.

Y dado:

decode
{"title":"Interstellar","director":"Christopher Nolan","year":2014,"rating":8.6}

Tu salida debería ser:

Title: Interstellar
Director: Christopher Nolan
Year: 2014
Rating: 8.6

Y dado:

decode
{"title":"Tenet","director":"Christopher Nolan","year":2020}

Tu salida debería ser:

Title: Tenet
Director: Christopher Nolan
Year: 2020
Rating: N/A

Hoja de referencia

El paquete encoding/json convierte structs de Go a JSON y viceversa usando json.Marshal y json.Unmarshal.

Para convertir un struct a JSON:

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

user := User{Name: "Alice", Email: "alice@example.com", Age: 30}
data, _ := json.Marshal(user)
fmt.Println(string(data))
// {"name":"Alice","email":"alice@example.com","age":30}

Para convertir JSON de nuevo a un struct:

jsonStr := `{"name":"Bob","email":"bob@example.com","age":25}`
var user User
json.Unmarshal([]byte(jsonStr), &user)
fmt.Println(user.Name)  // Bob

Las etiquetas de struct (struct tags) controlan el mapeo de campos JSON:

`json:"name"` - mapea el campo a la clave JSON "name"
`json:"price,omitempty"` - omite el campo si tiene un valor cero
`json:"-"` - excluye el campo de JSON por completo

type Product struct {
    ID       int     `json:"id"`
    Name     string  `json:"name"`
    Price    float64 `json:"price,omitempty"`
    Internal string  `json:"-"`
}

Solo los campos exportados (con mayúscula inicial) se incluyen en la salida JSON.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Leer el tipo de operación
	operation, _ := reader.ReadString('\n')
	operation = strings.TrimSpace(operation)

	if operation == "encode" {
		// Leer los detalles de la película
		title, _ := reader.ReadString('\n')
		title = strings.TrimSpace(title)

		director, _ := reader.ReadString('\n')
		director = strings.TrimSpace(director)

		yearStr, _ := reader.ReadString('\n')
		yearStr = strings.TrimSpace(yearStr)
		year, _ := strconv.Atoi(yearStr)

		ratingStr, _ := reader.ReadString('\n')
		ratingStr = strings.TrimSpace(ratingStr)
		rating, _ := strconv.ParseFloat(ratingStr, 64)

		// TODO: Crear una estructura Movie con los valores leídos
		// Establecer InternalID como "internal-123"
		// Convertir a JSON usando ToJSON e imprimir el resultado

	} else if operation == "decode" {
		// Leer la cadena JSON
		jsonStr, _ := reader.ReadString('\n')
		jsonStr = strings.TrimSpace(jsonStr)

		// TODO: Convertir JSON a Movie usando FromJSON
		// Imprimir los detalles de la película en el formato requerido
		// Usar fmt.Sprintf("%.1f", rating) para el formato de la calificación
		// Si rating es 0, imprimir "Rating: N/A" en su lugar

	}
}