BigInt

Description

Une valeur BigInt, parfois simplement appele BigInt, est un bigint primitif, cre en ajoutant un n la fin d'un littral d'entier, ou en appelant la fonction BigInt() (sans l'oprateur new) et en lui fournissant une valeur entire ou une chane de caractres.

const plusGrandEntier = 9007199254740991n;

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

const grandNombreEnChane = BigInt("9007199254740991");
// 9007199254740991n

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

const grandNombreOctal = BigInt("0o377777777777777777");
// 9007199254740991n

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

Les valeurs BigInt sont similaires aux valeurs Number sur certains aspects, mais diffrent aussi sur quelques points cls : les valeurs BigInt ne peuvent pas tre utilises avec les mthodes de l'objet natif Math et ne peuvent pas tre mlanges avec des valeurs Number dans des oprations ; elles doivent tre corces au mme type. Faites toutefois attention lors de la coercition entre ces types, car la prcision d'une valeur BigInt peut tre perdue lorsqu'elle est convertie en valeur Number.

Information de type

Lorsqu'on utilise typeof sur une valeur BigInt, cet oprateur donne "bigint" :

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

Un BigInt peut tre galement  envelopp  dans un Object :

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

Oprateurs

La plupart des oprateurs prennent en charge les BigInt, toutefois la plupart n'autorisent pas des oprandes de types mixtes les deux oprandes doivent tre des BigInt ou aucun ne doit l'tre :

• Oprateurs arithmtiques : +, -, *, /, %, **
• Oprateurs binaires : >>, <<, &, |, ^, ~
• Ngation unaire (-)
• Incrmentation/dcrmentation : ++, --

Les oprateurs qui retournent un boolen permettent de mlanger des valeurs Number et BigInt comme oprandes :

• Oprateurs relationnels et oprateurs d'galit : >, <, >=, <=, ==, !=, ===, !==
• Oprateurs logiques ne se basent que sur l'quivalent vrai des oprandes

Quelques oprateurs ne prennent pas du tout en charge BigInt :

• Plus unaire (+) ne peut pas tre pris en charge en raison d'un usage conflictuel dans asm.js, il a donc t laiss de ct pour ne pas casser asm.js (angl.).
• Dcalage droite non sign (>>>) est le seul oprateur binaire non pris en charge, car toute valeur BigInt est signe.

Cas particuliers :

• L'addition (+) impliquant une chane de caractres et un BigInt retourne une chane de caractres.
• La division (/) tronque les composantes fractionnaires vers zro, car BigInt ne peut pas reprsenter de quantits fractionnaires.

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

Comparaisons

Une valeur BigInt n'est pas strictement gal une valeur Number, mais elle l'est vaguement :

0n === 0; // false
0n == 0; // true

Une valeur Number et une valeur BigInt peuvent tre compares comme en temps normal :

1n < 2; // true
2n > 1; // true
2 > 2; // false
2n > 2; // false
2n >= 2; // true

On peut galement mlanger 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 fonctionne 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 numrique appropri
mixed.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]

Notez que les comparaisons entre les valeurs BigInt et les mmes valeurs, passes dans le constructeur Object(), ne sont pas quivalentes au sens strict :

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

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

Parce que la coercition entre des valeurs Number et des valeurs BigInt peut entraner une perte de prcision, il est recommand :

• Utiliser uniquement BigInt lorsque des valeurs suprieures 253 sont raisonnablement attendues.
• Ne pas effectuer de coercition entre des valeurs BigInt et des valeurs Number.

Oprations conditionnelles

Une valeur BigInt suit les mmes rgles de conversion que les valeurs Number dans les cas suivants :

• lorsqu'elle est convertie en Boolean : avec la fonction Boolean ;
• lorsqu'elle est utilise avec les oprateurs logiques ||, && et ! ; ou
• dans un test conditionnel comme une instruction if.

Autrement dit, seule la valeur 0n est quivalente faux ; toutes les autres sont quivalentes 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; // 12n
0n && 12n; // 0n
Boolean(0n); // false
Boolean(12n); // true
!12n; // false
!0n; // true

Cryptographie

Les oprations prises en charge pour les valeurs BigInt ne s'effectuent pas temps constant et sont donc sujettes des attaques temporelles. Aussi, BigInt ne saurait tre utilis des fins cryptographiques.

Utilisation avec JSON

L'utilisation de JSON.stringify() avec une valeur BigInt entrane une exception TypeError, car ces valeurs ne sont pas srialises en JSON par dfaut. Toutefois, JSON.stringify() laisse spcifiquement une porte drobe pour les valeurs BigInt : il essaie d'appeler la mthode toJSON() de BigInt. (Il ne le fait pas pour d'autres valeurs primitives.) Par consquent, vous pouvez implmenter votre propre mthode toJSON() (ce qui est l'un des rares cas o la modification des objets intgrs n'est pas explicitement dconseille) :

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

la place de lever une exception, JSON.stringify() produit maintenant une chane de caractres comme celle-ci :

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

Si vous ne souhaitez pas modifier BigInt.prototype, vous pouvez utiliser le paramtre replacer de JSON.stringify pour srialiser les valeurs BigInt :

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 donnes JSON contenant des valeurs dont vous savez qu'il s'agit de grands entiers, vous pouvez utiliser le paramtre reviver de la mthode JSON.parse() pour les dsrialiser :

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 analyss avec une prcision 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 le BigInt sous la forme d'un nombre JSON plutt que d'une chane de caractres JSON, voir Srialisation des nombres sans perte.

Constructeur

BigInt()

Cre une nouvelle valeur BigInt.

Mthodes statiques

BigInt.asIntN()

Tronque une valeur BigInt au nombre donn de bits les moins significatifs et retourne cette valeur en tant qu'entier sign.

BigInt.asUintN()

Tronque une valeur BigInt au nombre donn de bits les moins significatifs et retourne cette valeur en tant qu'entier non sign.

Proprits d'instance

Ces proprits sont dfinies sur BigInt.prototype et sont partages par toutes les instances de BigInt.

BigInt.prototype.constructor

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

BigInt.prototype[Symbol.toStringTag]

La valeur initiale de la proprit [Symbol.toStringTag] est la chane de caractres "BigInt". Cette proprit est utilise dans Object.prototype.toString(). Cependant, comme BigInt possde galement sa propre mthode toString(), cette proprit n'est utilise que si vous appelez Object.prototype.toString.call() avec un BigInt comme thisArg.

Mthodes d'instance

BigInt.prototype.toLocaleString()

Retourne une chane de caractres avec une reprsentation localise de la valeur BigInt. Il s'agit d'une surcharge de la mthode Object.prototype.toLocaleString().

BigInt.prototype.toString()

Retourne une chane de caractres avec une reprsentation de la valeur BigInt dans la base donne. Il s'agit d'une surcharge de la mthode Object.prototype.toString().

BigInt.prototype.valueOf()

Retourne la valeur BigInt. Il s'agit d'une surcharge de la mthode 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;
}

// Prend une valeur BigInt comme argument
// Retourne une valeur BigInt
function nthPrime(nth) {
  let maybePrime = 2n;
  let prime = 0n;

  while (nth >= 0n) {
    if (isPrime(maybePrime)) {
      nth--;
      prime = maybePrime;
    }
    maybePrime++;
  }

  return prime;
}

nthPrime(20n);
// 73n

Spcifications

Compatibilit des navigateurs

Voir aussi

• L'objet Number
• La proprit statique Number.MAX_SAFE_INTEGER