JavaScript BigInt

Índice

Variáveis JavaScript BigInt são usadas para armazenar grandes valores inteiros que são grandes demais para serem representados por um Número JavaScript normal.

Precisão de inteiro JavaScript

Os inteiros JavaScript são precisos apenas até 15 dígitos:

Precisão Inteira

let x = 999999999999999;
let y = 9999999999999999;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>Integer Precision</h2>

<p>Integers (numbers without a period or exponent notation) are accurate up to 15 digits:</p>

<p id="demo"></p>

<script>
let x = 999999999999999;
let y = 9999999999999999;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

Em JavaScript, todos os números são armazenados em formato de ponto flutuante de 64 bits (padrão IEEE 754).

Com este padrão, números inteiros grandes não podem ser representados com exatidão e serão arredondados.

Por causa disso, JavaScript só pode representar números inteiros com segurança:

Até 9007199254740991 +(2⁵³-1)

Até -9007199254740991 -(2⁵³-1).

Valores inteiros fora desse intervalo perdem precisão.

Como criar um BigInt

Para criar um BigInt, anexe n ao final de um número inteiro ou chame BigInt():

Exemplos

let x = 9999999999999999;
let y = 9999999999999999n;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>Integer and BigInt</h2>

<p id="demo"></p>

<script>
let x = 9999999999999999;
let y = BigInt("9999999999999999");
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

let x = 1234567890123456789012345n;
let y = BigInt(1234567890123456789012345)

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>Create a BigInt</h2>

<p id="demo"></p>

<script>
let x = 123456789012345678901234567890n;
let y = BigInt("123456789012345678901234567890");
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

BigInt: um novo tipo de dados JavaScript

O typeof JavaScript de um BigInt é "bigint":

Exemplo

let x = BigInt(999999999999999);
let type = typeof x;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>BigInt typeof</h2>

<p>The typeof a BigInt is:</p>
<p id="demo"></p>

<script>
let x = BigInt("9999999999999999");
document.getElementById("demo").innerHTML = typeof x;
</script>

</body>
</html>

BigInt é o segundo tipo de dados numéricos em JavaScript (depois de Número).

Com BigInt o número total de tipos de dados suportados em JavaScript é 8:

1. Cadeia
2. Número
3. Bigint
4. Booleano
5. Indefinido
6. Nulo
7. Símbolo
8. Objeto

Operadores BigInt

Operadores que podem ser usados em um Number JavaScript também pode ser usado em um BigInt.

Exemplo de multiplicação BigInt

let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavScript Bigint</h1>
<h2>BigInt Multiply</h2>
<p>Operators that can be used a Number can be used on a BigInt.</p>
<p id="demo"></p>

<script>
let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;

document.getElementById("demo").innerHTML = z; 
</script>

</body>
</html>

Notas

Aritmética entre um BigInt e um Número não é permitido (a conversão de tipo perde informações).

O deslocamento à direita não assinado (>>>) não pode ser feito em um BigInt (não tem largura fixa).

Decimais BigInt

Um BigInt não pode ter decimais.

Exemplo de divisão BigInt

let x = 5n;
let y = x / 2;
// Error: Cannot mix BigInt and other types, use explicit conversion.

let x = 5n;
let y = Number(x) / 2;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavScript Bigint</h1>
<h2>BigInt Divide</h2>

<p>A BigInt can not have decimals.</p>
<p>Cannot mix BigInt and other types, use explicit conversions.</p>
<p id="demo"></p>

<script>
let x = 5n;
let y = Number(x) / 2;

document.getElementById("demo").innerHTML = y; 
</script>

</body>
</html>

BigInt Hexadecimal, Octal e Binário

BigInt também pode ser escrito em notação hexadecimal, octal ou binária:

Exemplo hexadecimal BigInt

let hex = 0x20000000000003n;
let oct = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavScript Bigint</h1>
<h2>Hex, Octal and Binary</h2>

<p id="demo"></p>


<script>
let hex = 0x20000000000003n;
let oct = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n;

document.getElementById("demo").innerHTML = hex + "<br>" + oct + "<br>" + bin; 
</script>

</body>
</html>

Curiosidade de Precisão

O arredondamento pode comprometer a segurança do programa:

Exemplo MAX_SAFE_INTEGER

9007199254740992 === 9007199254740993; // is true !!!

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavScript Numbers</h1>
<h2>Integer Precision</h2>

<p>Is 9007199254740992 equal to 9007199254740993?</p>

<p id="demo"></p>


<script>
let x = 9007199254740992 === 9007199254740993;
document.getElementById("demo").innerHTML = x;
</script>

</body>
</html>

Suporte ao navegador

BigInt é compatível com todos os navegadores desde setembro de 2020:


Chrome 67	Edge 79	Firefox 68	Safari 14	Opera 54
May 2018	Jan 2020	Jul 2019	Sep 2020	Jun 2018

Inteiros Seguros Mínimos e Máximos

ES6 adicionou propriedades max e min ao objeto Number:

MAX_SAFE_INTEGER
MIN_SAFE_INTEGER

Exemplo MAX_SAFE_INTEGER

let x = Number.MAX_SAFE_INTEGER;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h2>Number Object Properties</h2>

<p>MAX_SAFE_INTEGER</p>

<p id="demo"></p>

<script>
let  x = Number.MAX_SAFE_INTEGER;
document.getElementById("demo").innerHTML = x;
</script>

</body>
</html>

Exemplo MIN_SAFE_INTEGER

let x = Number.MIN_SAFE_INTEGER;

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h2>Number Object Properties</h2>

<p>MIN_SAFE_INTEGER</p>

<p id="demo"></p>

<script>
let  x = Number.MIN_SAFE_INTEGER;
document.getElementById("demo").innerHTML = x;
</script>

</body>
</html>

Novos métodos numéricos

ES6 também adicionou 2 novos métodos ao objeto Number:

Number.isInteger()
Number.isSafeInteger()

O método Number.isInteger()

O método Number.isInteger() retorna true se o argumento for um número inteiro.

Exemplo: isInteger()

Number.isInteger(10);
Number.isInteger(10.5);

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>The isInteger() Method</h2>

<p>The isInteger() method returns true if the argument is an integer.</p>
<p>Otherwise it returns false.</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML =
Number.isInteger(10) + "<br>" + Number.isInteger(10.5);
</script>

</body>
</html>

O método Number.isSafeInteger()

Um número inteiro seguro é um número inteiro que pode ser representado exatamente como um número de precisão dupla.

O método Number.isSafeInteger() retorna true se o argumento for um número inteiro seguro.

Exemplo isSafeInteger()

Number.isSafeInteger(10);
Number.isSafeInteger(12345678901234567890);

Experimente você mesmo →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>The isSafeInteger() Method</h2>

<p>The isSafeInteger() method returns true if the argument is a safe integer.</p>
<p>Otherwise it returns false.</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML =
Number.isSafeInteger(10) + "<br>" + Number.isSafeInteger(12345678901234567890);
</script>

</body>
</html>

Inteiros seguros são todos números inteiros de -(2⁵³ - 1) a +(2⁵³ - 1).
Isto é seguro: 9007199254740991. Isto não é seguro: 9007199254740992.