Les variables JavaScript BigInt
sont utilisées pour stocker de grandes valeurs entières qui sont trop gros pour être représentés par un Nombre
JavaScript normal.
Les entiers JavaScript ne sont précis que jusqu'à 15 chiffres :
let x = 999999999999999;
let y = 9999999999999999;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Numbers</h1>
<h2>Integer Precision</h2>
<p>Integers (numbers without a period or exponent notation) are accurate up to 15 digits:</p>
<p id="demo"></p>
<script>
let x = 999999999999999;
let y = 9999999999999999;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>
</body>
</html>
En JavaScript, tous les nombres sont stockés dans un format à virgule flottante 64 bits (norme IEEE 754).
Avec cette norme, les grands entiers ne peuvent pas être représentés exactement et seront arrondis.
Pour cette raison, JavaScript ne peut représenter en toute sécurité que des entiers :
Jusqu'à 9007199254740991 +(253-1)
et
Jusqu'à -9007199254740991 -(253-1).
Les valeurs entières en dehors de cette plage perdent en précision.
Pour créer un BigInt
, ajoutez n à la fin d'un entier ou appelez BigInt()
:
let x = 9999999999999999;
let y = 9999999999999999n;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Numbers</h1>
<h2>Integer and BigInt</h2>
<p id="demo"></p>
<script>
let x = 9999999999999999;
let y = BigInt("9999999999999999");
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>
</body>
</html>
let x = 1234567890123456789012345n;
let y = BigInt(1234567890123456789012345)
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Numbers</h1>
<h2>Create a BigInt</h2>
<p id="demo"></p>
<script>
let x = 123456789012345678901234567890n;
let y = BigInt("123456789012345678901234567890");
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>
</body>
</html>
Le typeof
d'un BigInt
est "bigint" :
let x = BigInt(999999999999999);
let type = typeof x;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Numbers</h1>
<h2>BigInt typeof</h2>
<p>The typeof a BigInt is:</p>
<p id="demo"></p>
<script>
let x = BigInt("9999999999999999");
document.getElementById("demo").innerHTML = typeof x;
</script>
</body>
</html>
BigInt
est le deuxième type de données numériques en JavaScript (après Numéro
).
Avec BigInt
, le nombre total de types de données pris en charge en JavaScript est de 8 :
1. Chaîne
2. Numéro
3. Bigint
4. Booléen
5. Non défini
6. Nul
7. Symbole
8. Objet
Opérateurs pouvant être utilisés sur un Nombre
JavaScript peut également être utilisé sur un BigInt
.
let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavScript Bigint</h1>
<h2>BigInt Multiply</h2>
<p>Operators that can be used a Number can be used on a BigInt.</p>
<p id="demo"></p>
<script>
let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;
document.getElementById("demo").innerHTML = z;
</script>
</body>
</html>
Arithmétique entre un BigInt
et un Nombre
n'est pas autorisé (la conversion de type perd des informations).
Le décalage vers la droite non signé (>>>) ne peut pas être effectué sur un BigInt
(il n'a pas de largeur fixe).
Un BigInt
ne peut pas avoir de décimales.
let x = 5n;
let y = x / 2;
// Error: Cannot mix BigInt and other types, use explicit conversion.
let x = 5n;
let y = Number(x) / 2;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavScript Bigint</h1>
<h2>BigInt Divide</h2>
<p>A BigInt can not have decimals.</p>
<p>Cannot mix BigInt and other types, use explicit conversions.</p>
<p id="demo"></p>
<script>
let x = 5n;
let y = Number(x) / 2;
document.getElementById("demo").innerHTML = y;
</script>
</body>
</html>
BigInt
peut également être écrit en notation hexadécimale, octale ou binaire :
let hex = 0x20000000000003n;
let oct = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavScript Bigint</h1>
<h2>Hex, Octal and Binary</h2>
<p id="demo"></p>
<script>
let hex = 0x20000000000003n;
let oct = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n;
document.getElementById("demo").innerHTML = hex + "<br>" + oct + "<br>" + bin;
</script>
</body>
</html>
Les arrondis peuvent compromettre la sécurité du programme :
9007199254740992 === 9007199254740993; // is true !!!
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavScript Numbers</h1>
<h2>Integer Precision</h2>
<p>Is 9007199254740992 equal to 9007199254740993?</p>
<p id="demo"></p>
<script>
let x = 9007199254740992 === 9007199254740993;
document.getElementById("demo").innerHTML = x;
</script>
</body>
</html>
BigInt
est pris en charge dans tous les navigateurs depuis septembre 2020 :
Chrome 67 | Edge 79 | Firefox 68 | Safari 14 | Opera 54 |
May 2018 | Jan 2020 | Jul 2019 | Sep 2020 | Jun 2018 |
ES6 a ajouté les propriétés max et min à l'objet Number :
MAX_SAFE_INTEGER
MIN_SAFE_INTEGER
let x = Number.MAX_SAFE_INTEGER;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h2>Number Object Properties</h2>
<p>MAX_SAFE_INTEGER</p>
<p id="demo"></p>
<script>
let x = Number.MAX_SAFE_INTEGER;
document.getElementById("demo").innerHTML = x;
</script>
</body>
</html>
let x = Number.MIN_SAFE_INTEGER;
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h2>Number Object Properties</h2>
<p>MIN_SAFE_INTEGER</p>
<p id="demo"></p>
<script>
let x = Number.MIN_SAFE_INTEGER;
document.getElementById("demo").innerHTML = x;
</script>
</body>
</html>
ES6 a également ajouté 2 nouvelles méthodes à l'objet Number :
Number.isInteger()
Number.isSafeInteger()
La méthode Number.isInteger()
renvoie true
si l'argument est un entier.
Number.isInteger(10);
Number.isInteger(10.5);
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Numbers</h1>
<h2>The isInteger() Method</h2>
<p>The isInteger() method returns true if the argument is an integer.</p>
<p>Otherwise it returns false.</p>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML =
Number.isInteger(10) + "<br>" + Number.isInteger(10.5);
</script>
</body>
</html>
Un entier sûr est un entier qui peut être représenté exactement comme un nombre à double précision.
La méthode Number.isSafeInteger()
renvoie true
si l'argument est un entier sûr.
Number.isSafeInteger(10);
Number.isSafeInteger(12345678901234567890);
Essayez-le vous-même →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Numbers</h1>
<h2>The isSafeInteger() Method</h2>
<p>The isSafeInteger() method returns true if the argument is a safe integer.</p>
<p>Otherwise it returns false.</p>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML =
Number.isSafeInteger(10) + "<br>" + Number.isSafeInteger(12345678901234567890);
</script>
</body>
</html>
Les entiers sûrs sont tous des entiers compris entre -(253 - 1) et +(253 - 1).
C'est sûr : 9007199254740991. Ce n'est pas sûr : 9007199254740992.