Parsear JSON

Visión General

JSON es el formato de intercambio de datos de facto para las APIs modernas, los archivos de configuración y la comunicación entre servicios. Parsear JSON consiste en convertir una cadena con formato JSON en una estructura de datos nativa con la que tu lenguaje pueda trabajar (objetos, diccionarios, arrays).

Todos los lenguajes principales ofrecen soporte de JSON de primera clase, ya sea incorporado o mediante una librería consolidada. La forma idiomática de parsear JSON en Python, JavaScript y Java, además de manejo de errores, streaming para payloads grandes y validación con esquemas. Recursos relacionados: Analizar Archivos de Log.

Cuándo Usar

Usa esta receta cuando:

• Consumes una API REST que devuelve un payload JSON
• Lees configuración o datos almacenados en archivos .json
• Deserializas cuerpos de webhooks o eventos de una cola de mensajes
• Conviertes una cadena JSON en objetos tipados de tu modelo de dominio. Consulta Data Validation Zod para parsing basado en schemas.

Cuándo Evitar

• YAML o TOML para config editada por humanos: JSON no tiene comentarios ni strings multi-línea.
• Datos binarios: JSON codifica binario como base64, inflando el tamaño un 33%.
• Archivos enormes que no caben en memoria: usa parsers de streaming (ver sección Avanzado) en lugar de json. loads / JSON. parse.

Solución

Python

import json

raw = '{"name": "Ada", "age": 36, "skills": ["math", "code"]}'
data = json.loads(raw)

print(data["name"])      # "Ada"
print(data["skills"][0])  # "math"

Parsear desde un archivo:

import json

with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

Parsear con manejo de errores:

import json

try:
    data = json.loads(raw)
except json.JSONDecodeError as e:
    print(f"JSON inválido en línea {e.lineno}, col {e.colno}: {e.msg}")
    raise

JavaScript

const raw = '{"name": "Ada", "age": 36, "skills": ["math", "code"]}';
const data = JSON.parse(raw);

console.log(data.name);       // "Ada"
console.log(data.skills[0]);  // "math"

Parsear con función reviver para transformar valores durante el parseo:

const raw = '{"date": "2026-01-15", "count": "42"}';
const data = JSON.parse(raw, (key, value) => {
  if (key === 'count') return Number(value);
  if (key === 'date') return new Date(value);
  return value;
});
// data.date es un objeto Date, data.count es un número

Parsear con manejo de errores:

try {
  const data = JSON.parse(raw);
} catch (e) {
  if (e instanceof SyntaxError) {
    console.error('JSON inválido:', e.message);
  }
  throw e;
}

Java

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

ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(
    "{\"name\": \"Ada\", \"age\": 36}");

String name = node.get("name").asText(); // "Ada"
int age = node.get("age").asInt();        // 36

Mapear directamente a un POJO tipado:

public class User {
    public String name;
    public int age;
    public List<String> skills;
}

User user = mapper.readValue(jsonString, User.class);

Parsear con manejo de errores:

try {
    User user = mapper.readValue(json, User.class);
} catch (JsonProcessingException e) {
    log.error("JSON inválido: {}", e.getOriginalMessage());
    throw new IllegalArgumentException("Bad request", e);
}

Explicación

Cada lenguaje adopta un enfoque ligeramente distinto:

• Python usa el módulo incorporado json. json.loads() parsea una cadena; json.load() parsea desde un archivo. Devuelve estructuras nativas dict y list.
• JavaScript usa JSON.parse() incorporado. Devuelve objetos y arrays planos. Nunca uses eval() para parsear JSON: es un riesgo de seguridad.
• Java no tiene parser incorporado, así que añades una librería como Jackson o Gson. readTree() te da un árbol navegable; readValue() mapea directamente a POJOs tipados.

Una vez tengas los datos parseados, consulta Llamar a una API REST para obtener JSON por HTTP, o Leer y Escribir Archivos para cargarlo desde disco.

Variantes

Lenguaje	Herramienta	Devuelve	Parsear desde archivo
Python	json (stdlib)	dict / list	json.load(f)
JavaScript	JSON.parse() (nativo)	Object / Array	leer archivo y luego parsear
Java	Jackson / Gson	JsonNode / POJO	mapper.readValue(file, T.class)
Go	encoding/json (stdlib)	map[string]interface{} / struct	json.NewDecoder(r).Decode(&v)
Rust	serde_json crate	Value / struct	serde_json::from_reader(r)
C#	System.Text.Json (stdlib)	JsonElement / class	JsonSerializer.Deserialize<T>(stream)

Avanzado: Streaming de Archivos JSON Grandes

Cuando los archivos JSON son demasiado grandes para caber en memoria (GBs de datos), usa parsers de streaming que procesan el archivo incrementalmente.

Python con ijson

import ijson

def process_large_json(file_path):
    with open(file_path, 'rb') as f:
        for item in ijson.items(f, 'items.item'):
            process(item)

Java con Jackson Streaming

try (JsonParser parser = mapper.getFactory().createParser(new File("large.json"))) {
    while (parser.nextToken() != JsonToken.END_OBJECT) {
        String fieldName = parser.getCurrentName();
        if ("items".equals(fieldName)) {
            parser.nextToken(); // START_ARRAY
            while (parser.nextToken() != JsonToken.END_ARRAY) {
                Item item = parser.readValueAs(Item.class);
                process(item);
            }
        }
    }
}

JavaScript con stream-json

const fs = require('fs');
const streamJson = require('stream-json');

const pipeline = fs.createReadStream('large.json')
  .pipe(streamJson.parser());

pipeline.on('data', (data) => {
  if (data.name === 'startArray') {
    // manejar inicio de array
  }
});

Avanzado: Validación con JSON Schema

Valida la estructura del JSON antes de confiar en ella:

import jsonschema

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
    },
    "required": ["name"],
}

jsonschema.validate(data, schema)  # lanza ValidationError si es inválido

const Ajv = require('ajv');
const ajv = new Ajv();
const validate = ajv.compile(schema);

if (!validate(data)) {
  console.error(validate.errors);
}

Lo que funciona

• Maneja siempre los errores de parseo: envuelve el parseo en try/except (Python) o try/catch (JS/Java); el JSON externo no es de confianza.
• Prefiere modelos tipados en Java: mapea a POJOs con readValue() en lugar de navegar JsonNode por claves de texto.
• Nunca uses eval() en JavaScript: parse()`.
• Procesa payloads grandes en streaming: usa ijson (Python) o el JsonParser de Jackson para no cargar archivos enormes en memoria.
• Valida contra un esquema: para APIs propias, valida con JSON Schema antes de confiar en la estructura.

Errores Comunes

• Ignorar la codificación: JSON es UTF-8; leer un archivo con la codificación incorrecta corrompe los caracteres.
• No capturar nada: el JSON malformado lanza una excepción; fallar en silencio es peor que devolver un 400 claro.
• Precisión numérica en JavaScript: los enteros mayores que Number. MAX_SAFE_INTEGER pierden precisión; parsea los IDs grandes como cadenas.
• Confundir loads y load: en Python, loads recibe una cadena y load recibe un archivo.
• Confiar en el caso de las claves: las claves JSON distinguen mayúsculas; Name y name son campos distintos.

Troubleshooting

• Pipeline output does not match expectations: validate input schemas, intermediate states, and row counts at each step.
• Data quality degrades over time: add data validation checks and anomaly detection. Define SLIs for freshness, completeness, and accuracy.
• Job fails intermittently: look for race conditions, external dependencies, and resource contention. Retry with idempotency and bounded backoff.
• Schema changes break consumers: use schema registries and backward-compatible evolution.
• Storage costs grow unexpectedly: audit partition retention, compression, and duplicate copies. Archive cold data and set lifecycle policies.