BigInt

BigInt est un objet natif qui permet de représenter des nombres entiers supérieurs à 2⁵³ (la plus grande valeur entière qui puisse être représentée par le type primitif Number). BigInt peut être utilisé afin de représenter de grands entiers de n'importe quelle taille.

BigInt(valeur);

valeur

La valeur numérique de l'objet qu'on souhaite créer. Cet argument peut être une chaîne de caractères ou un entier.

Un objet BigInt est créé en ajoutant un n à la fin d'un littéral d'entier — 10n par exemple — ou en appelant la fonction BigInt().

const plusGrandEntier = 9007199254740991n;

const grandNombre = BigInt(9007199254740991);
// ↪ 9007199254740991n

const grandNombreEnChaîne = BigInt('9007199254740991');
// ↪ 9007199254740991n

const grandeNombreHexa = BigInt("0x1fffffffffffff");
// ↪ 9007199254740991n

const grandeNombreBinaire = BigInt("0b11111111111111111111111111111111111111111111111111111");
// ↪ 9007199254740991n

Les objets BigInt sont semblables aux objets Number selon certains aspects mais avec quelques différences clés. Les objets BigInt ne peuvent pas êre utilisés avec l'objet Math et ne peuvent pas être manipulés avec des opérations qui impliquent des objets Number.

Lorsqu'on utilise typeof sur une valeur BigInt, cet opérateur renverra "bigint" :

typeof 1n === "bigint"; // true
typeof BigInt("1") === "bigint"; // true

Lorsqu'on « enveloppe » la valeur dans un objet, on aura alors un type "object" (comme pour les autres valeurs primitives lorsqu'on les enveloppe dans le constructeur objet) :

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

On peut utiliser les opérateurs suivants avec les objets BigInt : +, `*`, `-`, `**`, `%` , les opérateurs binaires (à l'exception de >>> / décalage à droite avec des zéros) car les grands entiers sont signés. Le + unaire n'est pas non plus pris en charge (afin de ne pas casser asm.js).

const nombreSain = BigInt(Number.MAX_SAFE_INTEGER);
// ↪ 9007199254740991

const maxPlusUn = nombreSain + 1n;
// ↪ 9007199254740992n

const leFutur = nombreSain + 2n;
// ↪ 9007199254740993n, cela fonctionne désormais !

const multi = nombreSain * 2n;
// ↪ 18014398509481982n

const subtr = multi – 10n;
// ↪ 18014398509481972n

const mod = multi % 10n;
// ↪ 2n

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

bigN * -1n
// ↪ –18014398509481984n

L'opérateur / fonctionne de façon analogue aux nombres classiques. Toutefois, les objets BigInt permettent uniquement de représenter des entiers et non des nombres décimaux. Aussi, la division ne produira pas de partie décimale pour les BigInt.

const attendu = 4n / 2n;
// ↪ 2n

const tronque = 5n / 2n;
// ↪ 2n et pas 2.5n

Un objet BigInt n'est pas strictement égal à Number mais peut l'être au sens de l'égalité faible.

0n === 0
// ↪ false

0n == 0
// ↪ true

On peut toutefois comparer des objets Number et BigInt :

1n < 2
// ↪ true

2n > 1
// ↪ true

2 > 2
// ↪ false

2n > 2
// ↪ false

2n >= 2
// ↪ true

On peut également mélanger ces valeurs au sein de tableaux :

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]

On notera que les comparaisons entre les valeurs BigInt et les mêmes valeurs, passées dans le constructeur Object() ne seront pas équivalentes au sens strict :

0n === Object(0n); // false
Object(0n) === Object(0n); // false

const o = Object(0n);
o === o; // true

Un objet BigInt se comporte comme un objet Number lorsqu'il est utilisé dans un contexte booléen : comme argument pour le constructeur Boolean, comme opérandes pour les opérateurs logiques ||, `&&` et ! ou avec les instructions conditonnelles telles que if.

if (0n) {
  console.log('Nous voici dans le if !');
} else {
  console.log('Et nous voilà dans le else !');
}

// ↪ "Et nous voilà dans le else !"

0n || 12n
// ↪ 12n

0n && 12n
// ↪ 0n

Boolean(0n)
// ↪ false

Boolean(12n)
// ↪ true

!12n
// ↪ false

!0n
// ↪ true

BigInt.asIntN()

Écrète un objet BigInt pour obtenir un entier signé entre -2^largeur-1 et 2^largeur-1-1

BigInt.asUintN()

Écrète un objet BigInt pour obtenir un entier non-signé entre 0 et 2^largeur-1

BigInt.prototype

Cette propriété permet d'ajouter des propriétés aux objets BigInt.

L'ensemble des instances de BigInt héritent de BigInt.prototype. Le prototype du constructeur BigInt peut être modifié afin de modifier l'ensemble des instances de BigInt.

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/BigInt/prototype', 'Méthodes')}}

Lorsqu'on convertit une valeur BigInt en Number, on perd en précision. Si on effectue des allers-retours entre ces deux types, on ne conservera pas la même valeur. Aussi, il est recommandé d'utiliser uniquement BigInt lorsque les valeurs qu'on manipule seront supérieures à 2⁵³ et qu'il ne sera pas nécessaire de passer d'un type à l'autre.

Les opérations prises en charge pour les valeurs BigInt ne s'effectuent pas à temps constant. Aussi, BigInt ne serait être utilisé à des fins cryptographiques.

function isPrime(p) {
  for (let i = 2n; i * i <= p; i++) {
    if (p % i === 0n) return false;
  }
  return true;
}

// Takes a BigInt as an argument and returns a 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

• Number