Tag: BigInt

BigInt é um objeto nativo do JavaScript que fornece um modelo de representação de números inteiros maiores que , que é o maior número que o JavaScript consegue representar, com exatidão, utilizando o tipo primitivo Number.

Sintaxe:

A sintaxe do BigInt é:

BigInt(valor);

Onde:

• valor: é o valor numérico do objeto que irá ser criado. Este pode ser uma string ou um número inteiro.

É importante salientar que o BigInt() não é usado com o operador new.

O BigInt é criado com a simples acrescentação de um “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

O BigInt difere-se do Number em alguns assuntos importantes. Por exemplo:

• Ele não pode ser usado com métodos no objeto Math;
• Ele não pode ser misturado em operações ou qualquer instância de Number. Eles devem ser manipulados com o mesmo tipo.
• A precisão de BigInt pode ser perdida com a conversão de valores para Number.

Se você quiser realizar alguns testes, você pode:

• Testando com typeof:

typeof 1n === 'bigint'; // true

typeof BigInt('1') === 'bigint'; // true

• Se estiver envolvido em um Object, o BigInt será considerado como um tipo normal de “object”:

typeof Object(1n) === 'object'; // true

Você também pode realizar operações com BigInt ou com BigInt envolvido em objeto:

const antigoMaximoInt = BigInt(Number.MAX_SAFE_INTEGER);
// 9007199254740991

const maximoMaisUm = antigoMaximoInt + 1n;
// 9007199254740992n

const oFuturo= antigoMaximoInt + 2n;
// 9007199254740993n, isso funciona agora!

const multiplicando = antigoMaximoInt * 2n;
// 18014398509481982n

const subtraindo = multiplicando – 10n;
// 18014398509481972n

const modulo = multiplicando % 10n;
// 2n

const bigN = 2n ** 54n;
// 18014398509481984n

bigN * -1n
// –18014398509481984n

Observação:

O operador / também funciona. No entanto, se os números forem BigIntS e não BigDecimalS, a operação será arredondada para zero, o que não nos trará nenhum valor fracional.

const divisao = 4n / 2n;
// 2n

const arredondado = 5n / 2n;
// 2n, e não 2.5n

É importante salientar que o BigInt não é estritamente igual a um Number, mas eles podem ser comparados normalmente.

0n === 0;
// false

0n == 0;
// true

1n < 2;
// true

2n > 1;
// true

2 > 2;
// false

2n > 2;
// false

2n >= 2;
// true

O BigInt se comporta como um número quando é convertido em um booleano, e também pode ser usado com operadores lógicos , também dentro de uma estrutura condicional.

if (0n) {
    console.log("Olá, você está dentro do IF");
} else {
    console.log("Olá, você está dentro do ELSE");
}

0n || 12n;
// 12n

0n && 12n;
// 0n

Boolean(0n);
//  false

!0n;
// true

Propriedades:

BigInt.prototype;

Permite a adição de propriedades a um objeto BigInt. Todas as instâncias BigInt são herdadas do BigInt.prototype. O objeto de protótipo do construtor BigInt pode ser modificado para afetar todas as instâncias do BigInt.

Gostou deste artigo? Deixe seu comentário abaixo!