BigInt est un objet natif qui permet de représenter des nombres entiers supérieurs à 253 (la plus grande valeur entière qui puisse être représentée par le type Number).

Syntaxe

BigInt(valeur);

Paramètres

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.

Note : BigInt() n'est pas censé être utilisé avec l'opérateur new.

Description

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

const plusGrandEntier = 9007199254740991n;

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

const grandNombreEnChaîne = BigInt('9007199254740991');
// ↪ 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 ty objets Number.

Attention ! Il est nécessaire de convertir des valeurs Number ou BigInt dans les opérations qui les combinent.

Attention lors de ces conversions car la précision d'une valeur BigInt peut être perdue lorsque ce dernier est converti en Number.

Type

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

Opérateurs

On peut utiliser les opérateurs suivants avec les objets BigInt+, `*`, `-`, `**`, `%` .

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 arrondi = 5n / 2n;
// ↪ 2n, not 2.5n

Comparaisons

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

Opérations conditionnelles

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

Méthodes

BigInt.asIntN()
Écrète un objet BigInt entre -2largeur-1 et 2largeur-1-1
BigInt.asUintN()
Écrète un objet BigInt entre 0 et 2largeur-1

Propriétés

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

Instances de 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.

Méthodes

BigInt.prototype.toLocaleString()
Cette méthode renvoie une chaîne de caractères représentant le nombre et adaptée à la locale choisie. Cette méthode surcharge la méthode Object.prototype.toLocaleString().
BigInt.prototype.toString()
Cette méthode renvoie une chaîne de caractères représentant l'objet selon la base indiquée. Cette méthode surcharge la méthode Object.prototype.toString().
BigInt.prototype.valueOf()
Cette méthode renvoie la valeur primitive de l'objet indiqué. Cette méthode surcharge la méthode Object.prototype.valueOf().

Exemples

Calculer des nombres premiers

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

Étiquettes et contributeurs liés au document

Étiquettes : 
Contributeurs à cette page : SphinxKnight, sarahgp
Dernière mise à jour par : SphinxKnight,