BigInt représente des valeurs entières qui sonttrop élevées outrop faibles pour être représentées par le typeprimitifnumber.

Description

Unevaleur BigInt, parfois simplement appeléeBigInt, est unbigintprimitif, créée en ajoutant unn à la fin d'un littéral d'entier, ou en appelant la fonctionBigInt() (sans l'opérateurnew) et en lui fournissant une valeur entière ou une chaîne de caractères.

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 valeursBigInt sont similaires aux valeursNumber sur certains aspects, mais diffèrent aussi sur quelques points clés : les valeursBigInt ne peuvent pas être utilisées avec les méthodes de l'objet natifMath et ne peuvent pas être mélangées avec des valeursNumber dans des opérations ; elles doivent être coercées au même type. Faites toutefois attention lors de la coercition entre ces types, car la précision d'une valeurBigInt peut être perdue lorsqu'elle est convertie en valeurNumber.

Information de type

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

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

UnBigInt peut être également « enveloppé » dans unObject :

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

Opérateurs

La plupart des opérateurs prennent en charge lesBigInt, toutefois la plupart n'autorisent pas des opérandes de types mixtes — les deux opérandes doivent être desBigInt ou aucun ne doit l'être :

• Opérateurs arithmétiques :+,-,*,/,%,**
• Opérateurs binaires :>>,<<,&,|,^,~
• Négation unaire (-)
• Incrémentation/décrémentation :++,--

Les opérateurs qui retournent un booléen permettent de mélanger des valeursNumber etBigInt comme opérandes :

• Opérateurs relationnels etopérateurs d'égalité :>,<,>=,<=,==,!=,===,!==
• Opérateurs logiques ne se basent que sur l'équivalent à vrai des opérandes

Quelques opérateurs ne prennent pas du tout en chargeBigInt :

• Plus unaire (+) ne peut pas être pris en charge en raison d'un usage conflictuel dans asm.js, il a donc été laissé de côtépour ne pas casser asm.js^(angl.).
• Décalage à droite non signé (>>>) est le seul opérateur binaire non pris en charge, car toute valeur BigInt est signée.

Cas particuliers :

• L'addition (+) impliquant une chaîne et un BigInt retourne une chaîne de caractères.
• La division (/) tronque les composantes fractionnaires vers zéro, car BigInt ne peut pas représenter de quantités fractionnaires.

const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991nconst maxPlusOne = previousMaxSafe + 1n; // 9007199254740992nconst theFuture = previousMaxSafe + 2n; // 9007199254740993n, cela fonctionne désormais !const prod = previousMaxSafe * 2n; // 18014398509481982nconst diff = prod - 10n; // 18014398509481972nconst mod = prod % 10n; // 2nconst bigN = 2n ** 54n; // 18014398509481984nbigN * -1n; // -18014398509481984nconst expected = 4n / 2n; // 2nconst truncated = 5n / 2n; // 2n, pas 2.5n

Comparaisons

Une valeurBigInt n'est pas strictement égal à une valeurNumber, mais ellel'est vaguement :

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

Une valeurNumber et une valeurBigInt peuvent être comparées comme en temps normal :

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 :

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

Parce que la coercition entre des valeursNumber et des valeursBigInt peut entraîner une perte de précision, il est recommandé :

• Utiliser uniquementBigInt lorsque des valeurs supérieures à 2⁵³ sont raisonnablement attendues.
• Ne pas effectuer de coercition entre des valeursBigInt et des valeursNumber.

Opérations conditionnelles

Une valeurBigInt suit les mêmes règles de conversion que les valeursNumber dans les cas suivants :

• lorsqu'elle est convertie enBoolean : via la fonctionBoolean ;
• lorsqu'elle est utilisée avec lesopérateurs logiques||,&& et! ; ou
• dans un test conditionnel comme une instructionif.

Autrement dit, seule la valeur0n estéquivalent à faux ; toutes les autres sontéquivalent à vrai.

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

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,JSON.stringify() laisse spécifiquement une porte dérobée pour les valeursBigInt : il essaierait d'appeler la méthodetoJSON() deBigInt. (Il ne le fait pas pour d'autres valeurs primitives.) Par conséquent, vous pouvez implémenter votre propre méthodetoJSON() (ce qui est l'un des rares cas où la modification des objets intégrés n'est pas explicitement déconseillée) :

BigInt.prototype.toJSON = function () {  return { $bigint: this.toString() };};

À la place de lever une exception,JSON.stringify() produit maintenant une chaîne de caractères comme celle-ci :

console.log(JSON.stringify({ a: 1n }));// {"a":{"$bigint":"1"}}

Si vous ne souhaitez pas modifierBigInt.prototype, vous pouvez utiliser le paramètrereplacer deJSON.stringify pour sérialiser les valeursBigInt :

function replacer(cle, valeur) {  if (cle === "big") {    return valeur.toString();  }  return valeur;}const donnee = {  number: 1,  big: BigInt("18014398509481982"),};const chaine = JSON.stringify(donnee, replacer);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}

En fait, JSON permet d'utiliser des nombres de longueur arbitraire ; mais ils ne peuvent pas être analysés avec une précision totale en JavaScript. Si vous communiquez avec un autre programme dans un langage qui prend en charge des entiers plus longs (comme les entiers 64 bits) et que vous souhaitez transmettre leBigInt sous la forme d'un nombre JSON plutôt que d'une chaîne de caractères JSON, voirSérialisation des nombres sans perte.

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.

Propriétés d'instance

Ces propriétés sont définies surBigInt.prototype et sont partagées par toutes les instances deBigInt.

BigInt.prototype.constructor

La fonction constructeur qui a créé une instance de l'objet. Pour les instancesBigInt, la valeur initiale est le constructeurBigInt.

BigInt.prototype[Symbol.toStringTag]

La valeur initiale de la propriété[Symbol.toStringTag] est la chaîne de caractères"BigInt". Cette propriété est utilisée dansObject.prototype.toString(). Cependant, commeBigInt possède également sa propre méthodetoString(), cette propriété n'est utilisée que si vous appelezObject.prototype.toString.call() avec un BigInt commethisArg.

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().

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

• L'objetNumber
• La propriété statiqueNumber.MAX_SAFE_INTEGER