JavaScript BigInt
Qu'est-ce que JavaScript BigInt ?
BigInt est un type de données JavaScript permettant de gérer et de stocker des valeurs entières grandes .
BigInt vous permet de travailler avec des entiers supérieurs à la limite des Nombres .
BigInt peut représenter un entier de n'importe quelle taille , limité uniquement par la mémoire disponible.
Précision de JavaScript
Les Nombres JavaScript ne sont précis qu'à 15 chiffres :
Exemple
// 15 chiffres :
let x = 999999999999999;
// 16 chiffres :
let y = 9999999999999999; Les Nombres sont des Flottants 64 bits
Tous les Nombres JavaScript sont stockés dans un format flottant 64 bits (norme IEEE 754).
Avec cette norme, les grands nombres ne peuvent pas être représentés exactement et seront arrondis.
JavaScript ne peut représenter en toute sécurité des entiers jusqu'à 2 53 -1 (9007199254740991).
JavaScript ne peut représenter en toute sécurité des entiers jusqu'à -2 53 -1 (-9007199254740991).
Exemples
// MAX = 9007199254740991
let x = Number.MAX_SAFE_INTEGER;
// MIN = -9007199254740991
let y = Number.MIN_SAFE_INTEGER;
Les entiers supérieurs à Number.MAX_SAFE_INTEGER perdront de la précision :
// Max (précis)
let x = 9007199254740991;
// Max + 10 (imprécis)
let y = x + 10;
Les entiers inférieurs à Number.MIN_SAFE_INTEGER perdront de la précision :
// Min (précis)
let x = -9007199254740991;
// Min - 10 (imprécis)
let y = x - 10;
Remarque
Il n'existe pas de type entier en JavaScript.
Tous les Nombres JavaScript sont des flottants 64 bits.
Comment créer un BigInt
Vous pouvez créer un BigInt de deux manières :
- En utilisant un littéral entier avec un suffixe n
- En utilisant le constructeur BigInt() avec une chaîne
Exemples
// En utilisant un littéral entier avec un suffixe n :
let x = 999999999999999n;
// En utilisant le constructeur BigInt() avec une chaîne :
let y = BigInt("999999999999999"); let x = 12345678901234567890n;
let y = BigInt("12345678901234567890") Vous pouvez également créer un BigInt en utilisant le constructeur BigInt() avec un Nombre .
Avertissement !! Les Nombres ne sont précis qu'à 15 chiffres .
Exemples
let x = BigInt(9999999999999999);
BigInt est un type de données JavaScript
Le typeof d'un BigInt est "bigint" :
Exemple
let x = BigInt(999999999999999);
let type = typeof x; BigInt est le deuxième type de données numériques en JavaScript (après Number ).
Avec BigInt , le nombre total de types de données pris en charge en JavaScript est 8 :
1. Chaîne
2. Nombre
3. BigInt
4. Booléen
5. Indéfini
6. Nul
7. Symbole
8. Objet
Opérateurs Arithmétiques
BigInt prend en charge les opérateurs arithmétiques standards de JavaScript.
(+, -, ++, --, *, /, %, **)
Exemple
Multiplication :
let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y; Mélanger BigInt et Nombres
L'arithmétique entre un BigInt et un Nombre n'est pas autorisée (cela entraînera une TypeError ).
La conversion explicite doit être effectuée en premier .
Exemple
Vous ne pouvez pas mélanger BigInt et Nombre directement :
let x = 10n;
let y = 5;
let z = x + y; // ❌ TypeError Pour corriger cela, convertissez explicitement l'un :
let x = 10n;
let y = 5;
let z = Number(x) + y;
Conversions BigInt / Nombre
BigInt vers Nombre : Utilisez le constructeur Number().
Nombre vers BigInt : Utilisez le constructeur BigInt().
Exemple
// Créer un BigInt
let largeNumber = BigInt("12345678901234567890");
// Conversions
let num = Number(largeNumber);
Remarque
Les grands BigInts peuvent entraîner une valeur Infinity ou une perte de précision lorsqu'ils sont convertis en nombre.
BigInt Décimales
Un BigInt ne peut pas avoir de décimales.
let x = 1.5n; // ❌ TypeError
Exemple de Division BigInt
let x = 5n;
let y = x / 2;
// ❌ Erreur : Impossible de mélanger BigInt et d'autres types, utilisez une conversion explicite. let x = 5n;
let y = Number(x) / 2;
Remarque
Tenter de convertir un nombre avec une partie fractionnaire en BigInt générera une erreur.
Opérateurs de Comparaison
BigInt prend en charge les opérateurs de comparaison standards de JavaScript.
( <, > ==, ===, !==, <=, >= )
Les BigInts peuvent également être comparés avec des Nombres en utilisant des opérateurs de comparaison standard.
Exemple
Les Comparaisons fonctionnent normalement :
// vrai
let x = (10n > 5n);
// faux (types différents)
let y = (10n === 10);
// vrai (égalité lâche)
let z = (10n == 10);
Remarque
L'égalité stricte (===) entre un BigInt et un Nombre sera toujours fausse en raison des types différents.
Opérateurs Bit à Bit
BigInt prend en charge les opérations bit à bit, mais uniquement avec d'autres BigInts (pas des Nombres) :
- & (ET)
- | (OU)
- ^ (XOU)
- ~ (NON)
Exemple
let a = 5n; // 0101
let b = 3n; // 0011
let x = (a & b); // 1n (0001)
let y = (a | b); // 7n (0111)
let z = (a ^ b); // 6n (0110)
let n = (~a); // -6n
Opérateurs de Décalage Bit à Bit
BigInt ne prend en charge que deux opérateurs de décalage :
- << (décalage à gauche)
- >> (décalage à droite signé)
Exemple
let big = 10n; // binaire : 1010
let x = (big << 2n); // 40n (101000)
let y = (big >> 1n); // 5n (0101)
Règles Importantes :
- Les deux opérandes doivent être des BigInt
- Les montants de décalage doivent être non négatifs
- Le décalage à droite conserve le bit de signe pour les valeurs négatives
Remarque
Le décalage à droite non signé (>>>) n'est pas autorisé avec les BigInts.
BigInt Hex, Octal et Binaire
BigInt peut également être écrit en notation hexadécimale, octale ou binaire :
Comme les nombres, les littéraux bigint prennent en charge plusieurs bases :
- Normal : 256n
- Octal : 0o400n
- Hexadécimal : 0x100n
- Binaire : 0b100000000n
Exemples
let num = 256n;
let oct = 0o400n;
let hex = 0x100n;
let bin = 0b100000000n;
let hex = 0x20000000000003n;
let oct = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n; Curiosité sur la Précision
L'entier maximum sûr en JavaScript est 9007199254740991.
L'arrondi peut compromettre la sécurité du programme :
Exemples MAX_SAFE_INTEGER
9007199254740992 === 9007199254740993; // est vrai !!! 9007199254740992n === 9007199254740993n; // est faux !!! Résumé
BigInt permet des entiers à précision arbitraire .
Les nombres BigInt peuvent être aussi grands (ou petits) que votre mémoire le permet .
Les BigInt sont utilisés pour des entiers très grands (cryptographie, ID, horodatages, etc.).
BigInt n'est pas adapté pour les décimales - uniquement pour les entiers.
Les fonctions Math (comme Math.sqrt()) ne fonctionnent pas avec les BigInts.
JSON.stringify() ne peut pas gérer les BigInts - génère une erreur .
Support des Navigateurs
BigInt() est une fonctionnalité ES2020 .
ES2020 est entièrement pris en charge dans tous les navigateurs modernes depuis septembre 2020 :
| Chrome 85 | Edge 85 | Firefox 79 | Safari 14 | Opera 71 |
| Août 2020 | Août 2020 | Mars 2020 | Sept 2020 | Sept 2020 |