BigInt
Baseline
Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since setembro de 2020.
BigInt é um objeto nativo que fornece um modo de representar números inteiros maiores que 2^53, que é o maior número que o JavaScript consegue, com exatidão, representar com o tipo primitivo Number.
Sintaxe
BigInt(value);
Parâmetros
value-
O valor numérico do objeto que está sendo criado. Pode ser uma string ou um número inteiro.
Nota: Observação: BigInt() não é usado com o operador new.
Descrição
Um BigInt é criado com a acrescentação de n ao final de um inteiro literal — 10n — ou chamando a função BigInt().
const theBiggestInt = 9007199254740991n;
const alsoHuge = BigInt(9007199254740991);
// ↪ 9007199254740991n
const hugeString = BigInt("9007199254740991");
// ↪ 9007199254740991n
const hugeHex = BigInt("0x1fffffffffffff");
// ↪ 9007199254740991n
const hugeBin = BigInt(
"0b11111111111111111111111111111111111111111111111111111",
);
// ↪ 9007199254740991n
Isso é parecido com um Number em algumas partes, mas difere-se em alguns assuntos importantes — ele não pode ser usado com métodos no objeto Math e não pode ser misturado em operações ou qualquer instância de Number.
Aviso: Number e BigInt não podem ser misturados em operações — eles devem ser manipulados com o mesmo tipo.
Tenha cuidado com a conversão e desconversão de valores, visto que a precisão de BigInt pode ser perdida com a conversào para Number.
Informações do tipo
Quando testado com typeof , um BigInt vai devolver "bigint":
typeof 1n === "bigint"; // true
typeof BigInt("1") === "bigint"; // true
Quando envolvido em um Object, um BigInt vai ser considerado como um tipo normal de "object".
typeof Object(1n) === "object"; // true
Operadores
Os seguintes operadores podem ser usados com BigInts (ou com BigInts envolvidos em objetos): +, *, -, **, %.
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
// ↪ 9007199254740991
const maxPlusOne = previousMaxSafe + 1n;
// ↪ 9007199254740992n
const theFuture = previousMaxSafe + 2n;
// ↪ 9007199254740993n, isso funciona agora!
const multi = previousMaxSafe * 2n;
// ↪ 18014398509481982n
const subtr = multi – 10n;
// ↪ 18014398509481972n
const mod = multi % 10n;
// ↪ 2n
const bigN = 2n ** 54n;
// ↪ 18014398509481984n
bigN * -1n
// ↪ –18014398509481984n
O operador / também funciona com o esperado com números inteiros. No entanto, desde que esses sejam BigInts e não BigDecimals, essa operação vai arredondar para 0, o que significa que não vai retornar qualquer valor fracional.
Aviso:
Uma operação com um resultado fracional será arredondado com BigInt.
const expected = 4n / 2n;
// ↪ 2n
const rounded = 5n / 2n;
// ↪ 2n, e não 2.5n
Comparações
Um BigInt não é estritamente igual a um Number, mas é mais ou menos assim.
0n === 0;
// ↪ false
0n == 0;
// ↪ true
Um Number e um BigInt podem ser comparado normalmente.
1n < 2;
// ↪ true
2n > 1;
// ↪ true
2 > 2;
// ↪ false
2n > 2;
// ↪ false
2n >= 2;
// ↪ true
Eles podem ser misturados em arrays e ordenados.
const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
// ↪ [4n, 6, -12n, 10, 4, 0, 0n]
mixed.sort();
// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
Observe que comparações com BigInts envolvidos em Object atuam com outros objetos, indicando somente a igualdade onde a mesma instância do objeto é comparada.
0n === Object(0n); // false
Object(0n) === Object(0n); // false
const o = Object(0n);
o === o; // true
Condicionais
A BigInt comporta-se como Number nos casos onde ele é convertido para um Boolean: através da função Boolean; quando usado com operadores lógicos Logical Operators ||, &&, e !; ou dentro de um teste condicional como um if statement.
if (0n) {
console.log("Olá de um if!");
} else {
console.log("Olá de um else!");
}
// ↪ "Olá de um else!"
0n || 12n;
// ↪ 12n
0n && 12n;
// ↪ 0n
Boolean(0n);
// ↪ false
Boolean(12n);
// ↪ true
!12n;
// ↪ false
!0n;
// ↪ true
Métodos
BigInt.asIntN()-
Limita um BigInt entre -2expoente-1 e 2expoente-1-1
BigInt.asUintN()-
Limita um BigInt entre 0 e 2expoente-1
Propriedades
BigInt.prototype-
Permite a adição de propriedades a um objeto
BigInt.
Instâncias BigInt
Todas as instâncias BigInt são herdades de BigInt.prototype. O protótipo do objeto do construtor do BigInt pode ser modificado para afetar todas as instâncias de BigInt.
Métodos
Exemplos
Calculando números primos
function isPrime(p) {
for (let i = 2n; i * i <= p; i++) {
if (p % i === 0n) return false;
}
return true;
}
// Toma um BigInt como argumento e retorna um BigInt
function nthPrime(nth) {
let maybePrime = 2n;
let prime = 0n;
while (nth >= 0n) {
if (isPrime(maybePrime)) {
nth -= 1n;
prime = maybePrime;
}
maybePrime += 1n;
}
return prime;
}
nthPrime(20n);
// ↪ 73n