¿Cómo codificas/decodificas JSON en Go?

Question

Accepted Answer

El paquete **`encoding/json`** de la biblioteca estándar de Go maneja la serialización (marshaling) y deserialización (unmarshaling) de JSON, mapeando entre structs de Go y JSON. Las **etiquetas de struct** controlan el nombre de los campos, y es la base de la mayoría de las APIs web de Go.

## Marshaling: struct de Go → JSON

```go
type User struct {
    Name    string `json:"name"`              // tag maps the field to a JSON key
    Email   string `json:"email"`
    Age     int    `json:"age,omitempty"`     // omitempty → skip if zero/empty
    private string                             // unexported → NOT serialized (lowercase)
}

u := User{Name: "Ann", Email: "ann@x.com", Age: 30}
data, err := json.Marshal(u)
fmt.Println(string(data))   // {"name":"Ann","email":"ann@x.com","age":30}
```

`json.Marshal` convierte un struct a bytes JSON. **Solo los campos exportados (capitalizados) se serializan** — los campos no exportados se omiten.

## El rol de las etiquetas de struct

```go
type Product struct {
    ID    int    `json:"id"`                  // → "id"
    Name  string `json:"product_name"`        // → "product_name" (rename)
    Price float64 `json:"price,omitempty"`     // omit if 0
    Notes string `json:"-"`                    // "-" → NEVER serialize this field
}
```

Sin etiquetas, las claves JSON usan por defecto el nombre exacto del campo (capitalizado). Las etiquetas te permiten controlar el nombre de la clave JSON, omitir valores vacíos (`omitempty`), y excluir campos completamente (`-`) — esencial para coincidir con convenciones de API (p. ej. JSON en snake_case).

## Unmarshaling: JSON → struct de Go

```go
jsonData := []byte(`{"name":"Bob","email":"bob@x.com","age":25}`)

var user User
err := json.Unmarshal(jsonData, &user)   // pass a POINTER to populate it
if err != nil { log.Fatal(err) }
fmt.Println(user.Name)   // "Bob"
```

`json.Unmarshal` analiza JSON en un struct — debes pasar un **puntero** para que pueda poblar el struct. Los campos se cotejan por etiqueta/nombre (sin sensibilidad a mayúsculas).

## Trabajar con JSON desconocido/dinámico

```go
// when the structure is unknown, unmarshal into a map or interface{}
var result map[string]interface{}
json.Unmarshal(data, &result)
name := result["name"].(string)        // type-assert the value (JSON numbers → float64!)
```

## Streaming con Encoder/Decoder (para I/O)

```go
// encode directly to an io.Writer (e.g. an HTTP response) — efficient, no intermediate buffer
json.NewEncoder(w).Encode(user)

// decode directly from an io.Reader (e.g. an HTTP request body)
json.NewDecoder(r.Body).Decode(&user)
```

Para servidores web, `Encoder`/`Decoder` funcionan directamente con streams (cuerpos de solicitud/respuesta) — el patrón común en manejadores.

## Por qué es importante

La codificación/decodificación de JSON es fundamental para prácticamente todo desarrollo web en Go — APIs REST, microservicios, y configuración todos dependen de convertir entre structs de Go y JSON.

El paquete `encoding/json` (biblioteca estándar, sin dependencias) es la herramienta estándar, y comprenderla bien es conocimiento esencial del día a día: cómo funcionan marshaling/unmarshaling, la regla crítica de que **solo los campos exportados se serializan**, y especialmente las **etiquetas de struct** (controlando nombres de claves JSON con `json:"..."`, `omitempty` para saltar valores vacíos, `-` para excluir) que se necesitan para coincidir con convenciones de API del mundo real como snake_case.

Saber pasar un puntero a `Unmarshal`, manejar JSON dinámico mediante maps/`interface{}` (con la trampa de que números JSON se decodifican a `float64`), y usar `Encoder`/`Decoder` streaming para cuerpos HTTP cubre las necesidades prácticas de construir APIs.

Es una parte constante y práctica del trabajo backend en Go.