Pular para o conteúdo
FrAIFlow

Soluções

Por que IDs em JSON mudam depois do parsing

Um identificador JSON longo pode mudar antes de o formatador exibi-lo. Number do JavaScript não consegue representar exatamente todos os inteiros acima de 9007199254740991. Se um identificador passar por esse tipo, uma saída bem formatada pode já conter outros dígitos.

Relatos públicos descrevem JSON.parse alterando números grandes e perda de precisão no Google Apps Script. Um teste preservado com Node.js interpretou o número 9007199254740993 como 9007199254740992, enquanto a string entre aspas manteve seus dígitos. Esse resultado controlado não é um teste de uma API ao vivo nem do formatador atual do FrAIFlow.

Corrija a conversão antes de formatar a saída

Suponha que um ID de pedido termine em 993 na resposta, mas em 992 depois da importação. Primeiro, compare a resposta intacta com o objeto interpretado. Um formatador não consegue reparar um valor já arredondado. Preserve o arquivo original da resposta e evite abri-lo e salvá-lo novamente por outro importador numérico enquanto investiga.

const numeric = JSON.parse('{"id":9007199254740993}');
const exact = JSON.parse('{"id":"9007199254740993"}');
console.log(numeric.id); // 9007199254740992
console.log(exact.id);   // 9007199254740993
console.log(typeof exact.id); // string

Para um identificador, a segunda representação costuma ser a mais útil. Peça ao produtor da API para colocar o ID entre aspas e confira todos os consumidores: uma conversão posterior por Number(id) ou uma importação em planilha pode desfazer a correção. Um código de cliente não vira quantidade só porque contém dígitos.

Se o produtor não puder mudar, não faça o parsing primeiro para tentar reparar depois. Um reviver com acesso à origem pode ler o token original em runtimes compatíveis. O exemplo abaixo trata deliberadamente apenas um campo chamado id; adapte-o ao seu esquema em vez de converter todos os números.

let supportsSource = false;
JSON.parse("1", (key, value, context) => {
  supportsSource = context?.source === "1";
  return value;
});
if (!supportsSource) throw new Error("Use a lossless JSON parser");
const record = JSON.parse('{"id":9007199254740993}',
  (key, value, context) => {
    if (key === "id" && typeof value === "number") {
      if (!context || !/^-?\d+$/.test(context.source)) {
        throw new Error("Expected a decimal integer ID");
      }
      return context.source; // Keep the exact token as a string.
    }
    return value;
  });
console.log(record.id === "9007199254740993"); // true

Confira um valor logo abaixo e outro logo acima do limite de inteiros seguros; depois, exporte e reimporte uma amostra. Todos os dígitos devem coincidir com a origem. Se precisar de aritmética, não apenas identidade, adote uma estratégia explícita com BigInt ou decimal e defina como serializar a saída. Não transforme um Number arredondado em BigInt presumindo que a precisão perdida voltou.

O que a conversão numérica pode perder

Um reviver comum recebe um Number depois do parsing, tarde demais para recuperar dígitos descartados. O caminho com acesso à origem acima depende do suporte do runtime e do esquema do campo. Se não houver suporte, escolha um parser que preserve tokens. Não coloque tokens numéricos entre aspas com uma expressão regular ampla: ela também pode afetar conteúdo entre aspas ou campos que realmente devem ser numéricos.

Token numérico JSON / 9007199254740993 / Após parsing: 9007199254740992
Explicação criada pelos autores, não uma captura de aplicativo.

Para cálculos, construa BigInt a partir da string decimal original, não de um Number já arredondado. Planeje a serialização explicitamente: JSON.stringify comum não serializa valores BigInt diretamente. Um formato de exibição ou um remendo de zeros finais não restaura a identidade original.

O número JSON 9007199254740993 é arredondado para 9007199254740992; entre aspas, mantém todos os dígitos.
Ilustração explicativa em inglês. O número JSON 9007199254740993 é arredondado para 9007199254740992; entre aspas, mantém todos os dígitos.
O resultado do Node.js compara o identificador arredondado como Number com o valor exato preservado como string.
O resultado do Node.js compara o identificador arredondado como Number com o valor exato preservado como string. Resultado do exemplo sintético, não uma captura do aplicativo do usuário. Abra a imagem para ampliar.
Fontes, exemplos e leituras adicionais