Analizador de JSON

Parsear convierte texto en estructura. Esta página te muestra qué ha salido: los tipos, la profundidad de anidamiento, cuántas claves y arrays hay, qué números no sobrevivirán a un parser de JavaScript y dónde están las claves duplicadas.

Es la página que abres cuando te han pasado un payload y la primera pregunta es qué hay realmente aquí dentro.

Qué te dicen las estadísticas

Cada una responde a una pregunta que surge justo antes de ponerte a escribir código contra un documento.

Profundidad máxima

Hasta dónde llega el anidamiento. Por encima de unos cientos de niveles, comprueba qué hacen tus consumidores. Medido aquí: V8 parsea un millón de niveles pero se niega a serializar más allá de unos 4.800, y el escáner en C de CPython llega a unos 17.000 pese a un límite de recursión en Python de 1.000.

Número de claves y de objetos

Una medida aproximada del trabajo que hará un mapeador o un ORM, y de cuánto ocupará el árbol en memoria.

Números inseguros

Cuántos enteros superan 2^53-1. Si esto no es cero, cualquier consumidor JavaScript ya está leyendo valores distintos de los que hay en el archivo.

Claves duplicadas

Cuántas claves de objeto se definieron dos veces, con la posición de cada una.

Parsear no es lo mismo que validar una forma

Un documento puede parsearse perfectamente y seguir siendo inútil para ti: un campo renombrado, un número enviado como cadena, un array donde esperabas un objeto. Parsear comprueba la gramática, no el contrato.

Para el contrato, genera un JSON Schema a partir de un payload en el que confíes y valida los futuros payloads contra él.

En qué se diferencia este parser de JSON.parse

Es iterativo y no recursivo, así que la profundidad solo la limita la memoria. Registra el texto fuente exacto de cada número, de modo que nada se redondea en silencio. Sigue la posición de cada token, así que los errores tienen línea y columna. Y se recupera tras un error en vez de detenerse, así que un documento roto reporta todos sus problemas en una pasada.

El coste de todo eso es la velocidad: aproximadamente 12 a 16 MB por segundo aquí, frente a 60 o 70 de un JSON.parse nativo. Ese es el precio de la información, y es la razón por la que el trabajo se ejecuta en un worker en segundo plano.

How to do this in code

Parsear en código, incluidas las opciones que la gente suele descubrir demasiado tarde.

const value = JSON.parse(text);

// The reviver runs on every key and value, which is how you
// intercept large integers before precision is lost.
const value2 = JSON.parse(text, function (key, val) {
  if (typeof val === 'number' && !Number.isSafeInteger(val)) {
    // this[key] is the raw value; the original TEXT is not
    // available here, which is the limitation.
    console.warn('unsafe integer at', key);
  }
  return val;
});

import json
from decimal import Decimal

# parse_float and parse_int receive the raw TEXT of the number,
# so unlike JavaScript you can keep full precision.
data = json.loads(text, parse_float=Decimal, parse_int=int)

# Detect duplicate keys instead of silently keeping the last
def no_dupes(pairs):
    seen = {}
    for k, v in pairs:
        if k in seen:
            raise ValueError(f'duplicate key: {k}')
        seen[k] = v
    return seen

data = json.loads(text, object_pairs_hook=no_dupes)

// UseNumber keeps the original text instead of converting
// to float64, so large integers survive.
dec := json.NewDecoder(bytes.NewReader(data))
dec.UseNumber()

var v any
if err := dec.Decode(&v); err != nil {
    return err
}

ObjectMapper mapper = new ObjectMapper();

// Fail loudly on duplicates rather than keeping the last one
mapper.enable(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY);

// Keep big integers exact
mapper.enable(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS);

Preguntas frecuentes

¿Por qué mi número cambia tras parsearlo?

Porque los números JSON no tienen límite de tamaño y los doubles IEEE 754 sí. Cualquier entero por encima de 2^53-1 y muchos decimales no pueden representarse de forma exacta. Python, Go y Java ofrecen alguna manera de conservar el texto original; JavaScript no, y por eso los IDs grandes deberían enviarse como cadenas.

¿Qué pasa con las claves duplicadas?

La RFC 8259 lo deja sin definir. JavaScript y Python conservan la última aparición, algunas configuraciones de Go y Java rechazan el documento, y unos pocos parsers conservan la primera. No te apoyes nunca en ello. Esta página reporta cada duplicado con ambas posiciones.