BigInt estune enveloppe objet utilisée pour représenter et manipuler les valeursprimitivesbigint (grands entiers) qui permettent de représenter des valeursplus grandes que celles correctement représentables par une valeur primitive numérique (number).

Description

Ungrand entier, aussi appeléBigInt, est une valeur primitivebigint, créée en ajoutant unn à la fin d'un littéral d'entier —10n par exemple, ou en appelant le constructeurBigInt() (sans utiliser l'opérateurnew) en lui fournissant un entier ou une chaîne de caractères en argument.

const plusGrandEntier = 9007199254740991n;const grandNombre = BigInt(9007199254740991);// ↪ 9007199254740991nconst grandNombreEnChaîne = BigInt("9007199254740991");// ↪ 9007199254740991nconst grandeNombreHexa = BigInt("0x1fffffffffffff");// ↪ 9007199254740991nconst grandNombreOctal = BigInt("0o377777777777777777");// ↪ 9007199254740991nconst grandeNombreBinaire = BigInt(  "0b11111111111111111111111111111111111111111111111111111",);// ↪ 9007199254740991n

Les objetsBigInt sont semblables aux objetsNumber selon certains aspects mais avec quelques différences clés. Les objetsBigInt ne peuvent pas être utilisés avec les méthodes de l'objetMath et ne peuvent pas être manipulés avec des opérations qui impliquent des objetsNumber. Il est donc nécessaire de convertir des valeursNumber ouBigInt dans les opérations qui les combinent, mais attention lors de ces conversions car la précision d'une valeurBigInt peut être perdue lorsque ce dernier est converti enNumber.

Information de type

Lorsqu'on utilisetypeof sur une valeurBigInt, cet opérateur renverra"bigint" :

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

Lorsqu'on « enveloppe » la valeur primitive 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 objetsBigInt :

+ * - % **

Les opérateurs binaires sont également pris en charge (à 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 dene pas casserasm.js).

const nombreSain = BigInt(Number.MAX_SAFE_INTEGER);// ↪ 9007199254740991const maxPlusUn = nombreSain + 1n;// ↪ 9007199254740992nconst leFutur = nombreSain + 2n;// ↪ 9007199254740993n, cela fonctionne désormais !const multi = nombreSain * 2n;// ↪ 18014398509481982nconst subtr = multi - 10n;// ↪ 18014398509481972nconst mod = multi % 10n;// ↪ 2nconst bigN = 2n ** 54n;// ↪ 18014398509481984nbigN * -1n;// ↪ -18014398509481984n

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

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

Comparaisons

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

0n === 0;// ↪ false0n == 0;// ↪ true

On peut toutefois comparer des objetsNumber etBigInt :

1n < 2;// ↪ true2n > 1;// ↪ true2 > 2;// ↪ false2n > 2;// ↪ false2n >= 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]mixed.sort((a, b) => a - b);// ne fonctionnera pas car la soustraction ne// fonctionne pas sur des types mixtes// TypeError: can't convert BigInt value to Number value// On peut trier avec un comparateur numérique appropriémixed.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));// ↪ [ -12n, 0, 0n, 4n, 4, 6, 10 ]

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

0n === Object(0n); // falseObject(0n) === Object(0n); // falseconst o = Object(0n);o === o; // true

Opérations conditionnelles

Une valeurBigInt se comporte comme une valeurNumber lorsqu'elle est utilisée dans un contexte booléen : comme argument pour le constructeurBoolean, comme opérandes pour lesopérateurs logiques||,&& et! ou avec les instructions conditionnelles telles queif.

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;// ↪ 12n0n && 12n;// ↪ 0nBoolean(0n);// ↪ falseBoolean(12n);// ↪ true!12n;// ↪ false!0n;// ↪ true

Constructeur

BigInt()

Crée une nouvelle valeurBigInt.

Méthodes statiques

BigInt.asIntN()

Écrête une valeurBigInt en une valeur entière signée et renvoie cette valeur.

BigInt.asUintN()

Écrête une valeurBigInt en une valeur entière non-signée et renvoie cette valeur.

Méthodes d'instance

BigInt.prototype.toLocaleString()

Renvoie une chaîne de caractères avec une représentation localisée de la valeurBigInt. Il s'agit d'une surcharge de la méthodeObject.prototype.toLocaleString().

BigInt.prototype.toString()

Renvoie une chaîne de caractères avec une représentation de la valeurBigInt dans la base donnée. Il s'agit d'une surcharge de la méthodeObject.prototype.toString().

BigInt.prototype.valueOf()

Renvoie la valeurBigInt. Il s'agit d'une surcharge de la méthodeObject.prototype.valueOf().

Recommandations d'usage

Coercition enNumber

Lorsqu'on convertit une valeurBigInt enNumber, 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 uniquementBigInt lorsque les valeurs qu'on manipule seront supérieures à2^53 et qu'il ne sera pas nécessaire de passer d'un type à l'autre
• De ne pas passer d'un type à l'autre (BigInt àNumber et vice versa)

Cryptographie

Les opérations prises en charge pour les valeursBigInt ne s'effectuent pas à temps constant et sont donc sujettes à desattaques temporelles. Aussi,BigInt ne saurait être utilisé à des fins cryptographiques.

Utilisation avec JSON

L'utilisation deJSON.stringify() avec une valeurBigInt entraînera une exceptionTypeError, car ces valeurs ne sont pas sérialisées en JSON par défaut. Toutefois, il est possible d'utiliserle paramètre de remplacement deJSON.stringify pour sérialiser les propriétésBigInt sans erreur :

function remplacement(cle, valeur) {  if (cle === "big") {    return valeur.toString();  }  return valeur;}const donnee = {  number: 1,  big: BigInt("18014398509481982"),};const chaine = JSON.stringify(donnee, remplacement);console.log(chaine);// ↪ '{"number":1,"big":"18014398509481982"}'

Si vous avez des données JSON contenant des valeurs dont vous savez qu'il s'agit de grands entiers, vous pouvez utiliserle paramètrereviver de la méthodeJSON.parse() pour les désérialiser :

function reviver(cle, value) {  if (cle === "big") {    return BigInt(value);  }  return value;}const donnee = '{"number":1,"big":"18014398509481982"}';const deserialise = JSON.parse(donnee, reviver);console.log(deserialise);// ↪ {number: 1, big: 18014398509481982n}

Exemples

Calculer des nombres premiers

function isPrime(p) {  for (let i = 2n; i * i <= p; i++) {    if (p % i === 0n) return false;  }  return true;}// Prend une valeur BigInt comme argument// Renvoie une valeur BigIntfunction nthPrime(nth) {  let maybePrime = 2n;  let prime = 0n;  while (nth >= 0n) {    if (isPrime(maybePrime)) {      nth--;      prime = maybePrime;    }    maybePrime++;  }  return prime;}nthPrime(20n);// ↪ 73n

Spécifications

Compatibilité des navigateurs

Voir aussi

• Number
• Number.MAX_SAFE_INTEGER