Limite dos inteiros no JavaScript

No JavaScript, os números inteiros são armazenados utilizando o tipo de variável chamado Number, amplamente conhecido pela comunidade de programadores que já tiveram contato com a linguagem. Mas você sabia que a representação desses valores na memória RAM segue o padrão IEEE 754, amplamente utilizado para o armazenamento de números com ponto flutuante (como 2.3, 3.14, etc.)?

O que é IEEE 754 ?

Uma introdução rápida de IEEE 754, pois esse é um assunto longo e complexo, ele é um padrão técnico que especifica como valores de ponto flutuante devem ser armazenados (write) e interpretado (read) na memória RAM. Esse padrão define que, ao armazenar um número de ponto flutuante, ele não será armazenado diretamente como um valor “puro”. Em vez disso, ele é dividido em três componentes:

1. Sign Bit (bit de sinal)
2. Exponent (expoente)
3. Mantissa (ou fração significativa)

A partir desses três componentes, quando a CPU precisa interpretar um número de ponto flutuante, ela realiza uma equação baseada nos dados armazenados, para então obter o valor final. A fórmula básica é essa:

Como é alocado esses três componentes

Dependendo do comprimento total do número (em bits), temos diferentes níveis de precisão para valores de ponto flutuante. Os mais comuns são:

Half Precision (16 bits), Singles Precision (32 bits), Double Precision (64 bits), Quadruple precision (128 bits) e Octuple precision (256 bits). Cada tipo oferece maior ou menor alcance e precisão nos cálculos, conforme o comprimento.

Assim, ao inicializar uma variável de ponto flutuante, na verdade estamos alocando os "componentes" (bit de sinal, exponente e mantissa) na memória RAM, que servirão como entrada para a equação utilizada pela CPU para calcular o valor final.

Segue o exemplo abaixo de um Single Precision desse calculo:

Number é um Double Precision?

Sim! No JavaScript, o tipo primitivo Number segue o formato Double Precision definido pelo padrão IEEE 754. Isso significa que, ao armazenar números, a linguagem utiliza 64 bits de comprimento na memória RAM. No entanto, devido à sua natureza de ponto flutuante, o intervalo de possibilidades para números inteiros é limitado pela mantissa, que consiste em 52 bits mais o bit oculto (hidden bit), totalizando 53 bits. Portanto, o JavaScript tem um limite de precisão de 53 bits para números inteiros.

O valor máximo de 53 bits é representado pela constante Number.MAX_SAFE_INTEGER:

const maxInt = Number.MAX_SAFE_INTEGER;
const maxIntBin = 0b11111111111111111111111111111111111111111111111111111; // 53 bits

if (maxInt === maxInt) {
    console.log(maxInteger); // Output: 9007199254740991
}

Inteiros superiores a 53 bits no JavaScript

Quando trabalhamos com inteiros superiores ao valor de Number.MAX_SAFE_INTEGER, começam a ocorrer comportamentos imprevisíveis devido à limitação de precisão do formato de números de ponto flutuante no JavaScript. Veja o exemplo abaixo:

let maxInt = Number.MAX_SAFE_INTEGER;
console.log(maxInt); // Output: 9007199254740991

maxInt++; // Ok
console.log(maxInt); // Output: 9007199254740992

maxInt++; // Erro na precisão
console.log(maxInt); // Output: 9007199254740992 (valor não mudou)
// O valor permanece o mesmo que o anterior

// Mas, se adicionarmos mais 2
maxInt += 2; // Ok
console.log(maxInt); // Output: 9007199254740994

// Aqui ocorre outra inconsistência
maxInt++; // Erro na precisão
console.log(maxInt); // Output: 9007199254740994 (valor não mudou)

// Ao tentar novamente
maxInt++;
console.log(maxInt); // Output: 9007199254740996 (somou dois em vez de um)

Nesse caso acima, podemos verificar que 9007199254740993 não é um inteiro acessível. Isso ocorre porque o formato de ponto flutuante de Double Precision não possui precisão suficiente para representar esse valor corretamente, assim como muitos outros a partir de inteiros de 54 bits. Portanto, no JavaScript, ao trabalharmos com números inteiros superiores a 53 bits, eles deixam de ser seguros.

BigInt: Trabalhando com inteiros de grande magnitude

No JavaScript, existe um tipo de dado primitivo chamado BigInt, que permite lidar com inteiros de qualquer tamanho. Há duas formas de inicializá-lo: explícita e implícita.

// Inicializando BigInt explicitamente
const bigIntEx = BigInt(10);
console.log(typeof bigIntEx); // Output: "bigint"

// Inicializando BigInt implicitamente, usando o sufixo 'n'
const bigIntIm = 10n;
console.log(typeof bigIntIm); // Output: "bigint"

Inteiros grandes em JSON

A maioria dos dados transmitidos em sistemas utiliza o padrão JSON. No entanto, ao trabalhar com JavaScript, devemos tomar cuidado: não é seguro incluir inteiros superiores a 53 bits em um JSON, pois não temos garantia de que esses valores serão interpretados corretamente. Veja o exemplo:

// Aqui recebo id 9007199254740993
const responseApi = '{"id":9007199254740993,"hello":"world"}';

const data = JSON.parse(responseApi);
console.log(data.id); // Aqui se torna 9007199254740992

Nesse caso acima, 9007199254740993 foi interpretado incorretamente como 9007199254740992. Embora o BigInt permita lidar com números maiores que 53 bits, ele não é suportado no processo de serialização do JSON:

const data = {
  id: 9007199254740993n, // BigInt
  hello: "world",
};

console.log(data.id); // Ok, retorna: 9007199254740993n

// Mas ao tentar serializar...
JSON.stringify(data);
// TypeError: Do not know how to serialize a BigInt

Conclusão

Se você estiver trabalhando com identificadores numéricos (como IDs) em sistemas que utilizam JavaScript, é altamente recomendável convertê-los para string ao manipular esses valores. IDs geralmente não precisam de operações aritméticas, e tratá-los como string evita problemas de precisão quando eles ultrapassam o limite seguro de 53 bits. Isso garante consistência e segurança na manipulação desses valores em JSON e outras estruturas.