Esta página foi traduzida do inglês pela comunidade. Saiba mais e junte-se à comunidade MDN Web Docs.
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