Analisador de JSON

Fazer o parsing transforma texto em estrutura. Esta página mostra o que saiu dali: os tipos, a profundidade de aninhamento, quantas chaves e arrays existem, quais números não sobrevivem a um parser JavaScript e onde estão as chaves duplicadas.

É a página que você abre quando recebeu um payload e a primeira pergunta é o que realmente tem aqui dentro.

O que as estatísticas dizem

Cada uma responde a uma pergunta que aparece na hora de escrever código contra um documento.

Profundidade máxima

Até onde o aninhamento vai. Acima de algumas centenas de níveis, verifique o que os seus consumidores fazem. Medido aqui: o V8 faz o parsing de um milhão de níveis mas se recusa a serializar além de cerca de 4.800, e o scanner em C do CPython chega a uns 17.000 apesar de um limite de recursão do Python de 1.000.

Contagem de chaves e de objetos

Uma medida grosseira do trabalho que um mapeador ou um ORM vai ter, e do tamanho que a árvore vai ocupar em memória.

Números inseguros

Quantos inteiros passam de 2^53-1. Se isso não for zero, qualquer consumidor JavaScript já está lendo valores diferentes dos que estão no arquivo.

Chaves duplicadas

Quantas chaves de objeto foram definidas duas vezes, com a posição de cada uma.

Fazer parsing não é validar um formato

Um documento pode fazer o parsing perfeitamente e ainda ser inútil para você: um campo renomeado, um número enviado como string, um array onde se esperava um objeto. O parsing verifica a gramática, não o contrato.

Para o contrato, gere um JSON Schema a partir de um payload em que você confia e valide os próximos payloads contra ele.

No que este parser difere do JSON.parse

Ele é iterativo em vez de recursivo, então a profundidade só é limitada pela memória. Ele guarda o texto de origem exato de cada número, então nada é arredondado em silêncio. Ele acompanha a posição de cada token, então os erros têm linha e coluna. E ele se recupera depois de um erro em vez de parar, então um documento quebrado reporta todos os problemas em uma passada.

O custo disso tudo é velocidade: por volta de 12 a 16 MB por segundo aqui, contra 60 a 70 de um JSON.parse nativo. É o preço da informação, e é por isso que o trabalho roda em um worker em segundo plano.

How to do this in code

Fazendo parsing em código, incluindo as opções que em geral se descobre tarde demais.

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);

Perguntas frequentes

Por que o meu número mudou depois do parsing?

Porque números JSON não têm limite de tamanho e doubles IEEE 754 têm. Qualquer inteiro acima de 2^53-1 e muitos decimais não podem ser representados exatamente. Python, Go e Java oferecem alguma forma de manter o texto original; o JavaScript não, e é por isso que IDs grandes deveriam ser enviados como strings.

O que acontece com chaves duplicadas?

A RFC 8259 deixa indefinido. JavaScript e Python ficam com a última ocorrência, algumas configurações de Go e Java rejeitam o documento, e alguns parsers ficam com a primeira. Nunca conte com isso. Esta página reporta cada duplicata com as duas posições.