JavaScript - BigInt: Gérer des nombres vraiment très grands

Salut à toi, aspirant(e)s codeur(euse)s ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des nombres vraiment, vraiment très grands en JavaScript. Attachez vos ceintures, car nous allons explorer le fascinant royaume du BigInt !

Qu'est-ce que BigInt ?

Imaginez que vous comptez des étoiles dans le ciel nocturne. Vous comptez et comptez, mais soudain votre calculatrice dit "Infini". Frustrant, n'est-ce pas ? C'est là que BigInt vient à la rescousse !

BigInt est un type numérique spécial en JavaScript qui peut représenter des entiers de longueur arbitraire. Contrairement aux nombres réguliers, qui ont des limitations, BigInt peut gérer des nombres aussi grands que votre imagination (ou la mémoire de votre ordinateur) le permet.

Pourquoi avons-nous besoin de BigInt ?

En JavaScript, les nombres réguliers sont stockés sur 64 bits, ce qui signifie qu'ils ont une valeur maximale sicher de 9 007 199 254 740 991. C'est un grand nombre, mais dans le monde de l'informatique, il arrive parfois que nous devions aller encore plus loin !

Voyons ce qui se passe lorsque nous tentons de dépasser cette limite :

console.log(9007199254740991n + 1n); // 9007199254740992n
console.log(9007199254740991n + 2n); // 9007199254740992n (Oops ! Même résultat)

Comme vous pouvez le voir, JavaScript ne peut pas représenter avec précision les nombres au-delà de cette limite. C'est là que BigInt brille !

Déclaration et Initialisation

Créer un BigInt est aussi simple que pie. Vous avez deux options :

1. Ajouter 'n' à la fin d'un entier
2. Utiliser la fonction BigInt()

Essayons les deux :

const bigNumber1 = 1234567890123456789012345678901234567890n;
const bigNumber2 = BigInt("9007199254740991");

console.log(bigNumber1); // 1234567890123456789012345678901234567890n
console.log(bigNumber2); // 9007199254740991n

Notez le 'n' à la fin ? C'est ainsi que JavaScript sait qu'il s'agit d'un BigInt !

Opérations de base

Maintenant que nous avons nos grands nombres, penchons-nous sur un peu de mathématiques !

const a = 1234567890n;
const b = 9876543210n;

console.log(a + b);  // 11111111100n
console.log(a - b);  // -8641975320n
console.log(a * b);  // 12193263111263526900n
console.log(a / b);  // 0n (Division entière)
console.log(a % b);  // 1234567890n

Souvenez-vous, les BigInts sont toujours des nombres entiers. Lors de la division, le résultat est arrondi vers le bas au plus proche entier.

Comparaison

Comparer des BigInts est exactement comme comparer des nombres réguliers :

console.log(5n > 4n);   // true
console.log(5n < 4n);   // false
console.log(5n === 5);  // false (différents types)
console.log(5n == 5);   // true (coercition de type)

Notez les deux dernières lignes. Les BigInts et les nombres réguliers sont considérés comme égaux lors de l'utilisation de ==, mais pas avec ===. Cela est dû au fait que === vérifie à la fois la valeur et le type.

Conversions

Parfois, vous devrez convertir entre BigInts et des nombres réguliers. Voici comment :

const bigNum = 123456789n;
const regularNum = Number(bigNum);

console.log(regularNum);  // 123456789

const backToBigInt = BigInt(regularNum);
console.log(backToBigInt);  // 123456789n

Soyez prudent lorsque vous convertissez de grands BigInts en nombres réguliers, car vous pourriez perdre la précision !

Exemples

Mettons nos connaissances sur BigInt à l'œuvre avec quelques exemples du monde réel :

1. Calcul des Factoriels

function factorial(n) {
if (n === 0n) return 1n;
return n * factorial(n - 1n);
}

console.log(factorial(20n));  // 2432902008176640000n

Cette fonction peut calculer les factoriels de nombres bien plus grands que ce serait possible avec des nombres JavaScript réguliers !

2. Travailler avec de très grands nombres premiers

function isPrime(n) {
if (n <= 1n) return false;
for (let i = 2n; i * i <= n; i++) {
if (n % i === 0n) return false;
}
return true;
}

const largeNumber = 2n ** 100n - 1n;
console.log(isPrime(largeNumber) ? "Premier" : "Non Premier");  // Non Premier

Cette fonction peut vérifier la primalité pour des nombres bien au-delà des limites des nombres JavaScript réguliers !

Gestion des erreurs avec BigInt

Lorsque vous travaillez avec BigInts, il y a quelques chose à surveiller :

try {
const result = 1n + 1;  // Cela lancera une erreur
} catch (error) {
console.log("Erreur:", error.message);  // Cannot mix BigInt and other types
}

try {
const result = Math.sqrt(4n);  // Cela lancera également une erreur
} catch (error) {
console.log("Erreur:", error.message);  // Cannot convert a BigInt value to a number
}

Souvenez-vous, les BigInts ne peuvent être utilisés qu'avec d'autres BigInts pour des opérations arithmétiques, et de nombreuses fonctions Math ne supportent pas les BigInts.

Méthodes BigInt

Voici un tableau des méthodes BigInt les plus couramment utilisées :

Méthode	Description	Exemple
BigInt()	Crée une valeur BigInt	BigInt(123)
BigInt.asIntN()	Enveloppe une valeur BigInt dans un entier signé entre -2^(n-1) et 2^(n-1)-1	BigInt.asIntN(3, 5n) // 5n
BigInt.asUintN()	Enveloppe une valeur BigInt dans un entier unsigned entre 0 et 2^n-1	BigInt.asUintN(3, 5n) // 5n
BigInt.prototype.toString()	Retourne une représentation string d'une valeur BigInt	(123n).toString() // "123"
BigInt.prototype.valueOf()	Retourne la valeur primitive d'un objet BigInt	Object(123n).valueOf() // 123n

Et voilà, les amis ! Vous êtes maintenant équipés pour gérer des nombres plus grands que les étoiles dans le ciel. Souvenez-vous, avec un grand pouvoir vient une grande responsabilité - utilisez vos BigInts avec sagesse !

Bonne programmation, et puissent vos nombres toujours être aussi grands que vos rêves !

Credits: Image by storyset