Parseo de JSON

Qué es JSON

JSON (JavaScript Object Notation) es un formato de texto para el intercambio de datos, cómodo tanto para la lectura por personas como para el procesamiento por máquinas. Pese a haber nacido en JavaScript, hace tiempo que se convirtió en un estándar independiente del lenguaje y se utiliza prácticamente en cualquier lugar donde las aplicaciones necesitan intercambiar datos estructurados.

Ejemplo básico de un documento JSON:

{
  "id": 42,
  "name": "Ana",
  "is_active": true,
  "roles": ["admin", "editor"],
  "profile": {
    "city": "Madrid",
    "age": 29
  }
}

El formato se compone de unos pocos tipos simples: objetos (pares «clave-valor»), arrays, cadenas, números, valores booleanos y null. Esa sencillez es justamente la causa de su difusión universal.

Qué es el parseo de JSON y para qué sirve

El parseo de JSON (análisis) es el proceso de convertir el texto JSON en una estructura de datos que un lenguaje de programación concreto entienda: un objeto, un diccionario, un array, una lista, etc. En esencia, el parser toma una cadena de caracteres y la transforma en objetos vivos con los que se puede trabajar en el código.

El proceso inverso — convertir los objetos del programa de nuevo en una cadena JSON — se llama serialización (o marshalling). El parseo y la serialización casi siempre van en pareja.

El parseo aparece en tareas muy habituales:

• Trabajo con API — recepción y envío de datos por HTTP (más abajo entramos en detalle).
• Archivos de configuración — muchas herramientas guardan sus ajustes en JSON (package.json, tsconfig.json, etc.).
• Almacenamiento e intercambio de datos — logs, mensajes en colas (Kafka, RabbitMQ), documentos en bases NoSQL (MongoDB).
• Comunicación entre servicios en una arquitectura de microservicios.
• Persistencia del estado de la aplicación en archivos o en el localStorage del navegador.

Parseo de JSON al trabajar con API

El escenario más frecuente en el que una persona desarrolladora se topa con el parseo de JSON es la interacción con una API. La inmensa mayoría de las web API modernas (REST, y a menudo otros estilos) intercambian datos precisamente en formato JSON.

El ciclo típico de trabajo con una API es el siguiente:

1. El cliente envía una petición HTTP a un endpoint de la API.
2. El servidor responde con un cuerpo en forma de cadena JSON.
3. El cliente parsea esa cadena, la convierte en objetos y sigue trabajando con los datos.
4. Al enviar datos (POST, PUT), el cliente hace lo contrario: serializa sus objetos a JSON.

Sin el paso del parseo, la respuesta del servidor no es más que texto, con el que no se puede trabajar cómodamente de forma programática. Por eso el parseo es un eslabón obligatorio en casi cualquier integración con un servicio externo.

Véase también: el artículo «Extracción de datos vía API» — allí se explica en detalle cómo se estructuran las peticiones a una API, cómo procesar las respuestas y trabajar con cabeceras, códigos de estado, paginación y autenticación. Este artículo se centra precisamente en la etapa de análisis de los propios datos JSON, que forma parte de ese proceso.

Ejemplos de parseo de JSON en distintos lenguajes

A continuación se muestran ejemplos de parseo de JSON en lenguajes populares. En todos los casos se parsea la misma cadena y luego se extrae el valor de un campo anidado.

Python

La biblioteca estándar incluye el módulo json. El método loads parsea una cadena; load, el contenido de un archivo.

import json

data_str = '{"name": "Ana", "profile": {"city": "Madrid", "age": 29}}'

# Parseo de la cadena a un diccionario
data = json.loads(data_str)

print(data["name"])              # Ana
print(data["profile"]["city"])   # Madrid

# Operación inversa: serialización
back_to_str = json.dumps(data, ensure_ascii=False)

JavaScript

En JavaScript el parseo está integrado en el lenguaje mediante el objeto global JSON. Es, de hecho, el formato «nativo» del ecosistema.

const dataStr = '{"name": "Ana", "profile": {"city": "Madrid", "age": 29}}';

// Parseo de la cadena a un objeto
const data = JSON.parse(dataStr);

console.log(data.name);            // Ana
console.log(data.profile.city);    // Madrid

// Operación inversa
const backToStr = JSON.stringify(data);

Al trabajar con fetch, el parseo de la respuesta de la API se hace en una sola línea:

const response = await fetch("https://api.example.com/users/42");
const user = await response.json(); // la respuesta ya viene parseada como objeto
console.log(user.name);

Java

La biblioteca estándar no trae un parser integrado, así que se suelen usar bibliotecas — por ejemplo, Jackson o Gson. Ejemplo con Jackson:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        String dataStr = "{\"name\": \"Ana\", \"profile\": {\"city\": \"Madrid\"}}";

        ObjectMapper mapper = new ObjectMapper();
        JsonNode node = mapper.readTree(dataStr);

        System.out.println(node.get("name").asText());                  // Ana
        System.out.println(node.get("profile").get("city").asText());   // Madrid
    }
}

Lo más habitual es parsear el JSON directamente a una clase tipada (POJO):

record Profile(String city, int age) {}
record User(String name, Profile profile) {}

User user = mapper.readValue(dataStr, User.class);
System.out.println(user.profile().city());

Go

La biblioteca estándar incluye el paquete encoding/json. Los datos se suelen parsear a una struct con etiquetas en los campos.

package main

import (
    "encoding/json"
    "fmt"
)

type Profile struct {
    City string `json:"city"`
    Age  int    `json:"age"`
}

type User struct {
    Name    string  `json:"name"`
    Profile Profile `json:"profile"`
}

func main() {
    dataStr := `{"name": "Ana", "profile": {"city": "Madrid", "age": 29}}`

    var user User
    json.Unmarshal([]byte(dataStr), &user)

    fmt.Println(user.Name)          // Ana
    fmt.Println(user.Profile.City)  // Madrid
}

C

El .NET moderno incluye el espacio de nombres integrado System.Text.Json.

using System;
using System.Text.Json;

class Program
{
    static void Main()
    {
        string dataStr = "{\"name\": \"Ana\", \"profile\": {\"city\": \"Madrid\"}}";

        using JsonDocument doc = JsonDocument.Parse(dataStr);
        JsonElement root = doc.RootElement;

        Console.WriteLine(root.GetProperty("name").GetString());                       // Ana
        Console.WriteLine(root.GetProperty("profile").GetProperty("city").GetString()); // Madrid
    }
}

PHP

En PHP el parseo está integrado en el lenguaje mediante las funciones json_decode y json_encode.

<?php
$dataStr = '{"name": "Ana", "profile": {"city": "Madrid", "age": 29}}';

// true: parsear a un array asociativo en lugar de a un objeto
$data = json_decode($dataStr, true);

echo $data["name"];             // Ana
echo $data["profile"]["city"];  // Madrid

// Operación inversa
$backToStr = json_encode($data, JSON_UNESCAPED_UNICODE);

Rust

En el ecosistema de Rust, el estándar de facto es el crate serde junto con serde_json.

use serde::Deserialize;

#[derive(Deserialize)]
struct Profile {
    city: String,
    age: u32,
}

#[derive(Deserialize)]
struct User {
    name: String,
    profile: Profile,
}

fn main() {
    let data_str = r#"{"name": "Ana", "profile": {"city": "Madrid", "age": 29}}"#;

    let user: User = serde_json::from_str(data_str).unwrap();

    println!("{}", user.name);          // Ana
    println!("{}", user.profile.city);  // Madrid
}

Comparación de enfoques

Se aprecian dos enfoques principales para el análisis:

• Parseo dinámico — el JSON se convierte en una estructura genérica (diccionario, array, árbol de nodos). Cómodo para un trabajo rápido y flexible, pero sin comprobación de tipos en tiempo de compilación.
• Parseo tipado — el JSON se mapea directamente a clases o structs definidas de antemano. Más seguro y más claro, sobre todo en lenguajes de tipado estricto (Java, Go, Rust, C#).

Problemas frecuentes y recomendaciones

Al parsear JSON conviene tener en cuenta varias dificultades típicas:

• JSON no válido. Si la cadena está dañada o contiene errores de sintaxis, el parser lanzará una excepción. El análisis de datos externos conviene envolverlo siempre en un manejo de errores.
• Campos ausentes o null. No dé por hecho que todas las claves esperadas están siempre presentes: la API puede enviar un objeto incompleto. Compruebe que el campo existe antes de acceder a él.
• Codificación. El estándar JSON usa UTF-8. En algunos lenguajes (Python, PHP) hay que indicar flags de forma explícita para que los caracteres no ASCII (acentos, ñ) no se conviertan en secuencias \u al serializar.
• Documentos grandes. Para archivos muy grandes, en lugar de cargar todo el objeto en memoria se recurre al parseo en flujo (streaming), que lee los datos por partes.
• Números y precisión. Los enteros grandes y los números en coma flotante pueden perder precisión — algo crítico para los datos financieros, que a veces se transmiten como cadenas.

Conclusión

El parseo de JSON es una habilidad básica sin la cual resulta casi imposible trabajar con las API modernas e intercambiar datos entre sistemas. El formato en sí es universal, y las herramientas para analizarlo existen en todos los lenguajes de programación extendidos: unas integradas, otras en forma de bibliotecas populares. El principio es siempre el mismo — convertir una cadena de texto en objetos cómodos para el código y, cuando hace falta, recorrer el camino inverso.

Para ver cómo el parseo encaja en el ciclo completo de interacción con servicios externos, consulte el artículo «Extracción de datos vía API».