JavaScript BigInt

Introduction à JavaScript BigInt

BigInt est un type primitif JavaScript intégré qui représente des entiers de taille arbitraire — des nombres entiers bien plus grands que ce que le type Number classique peut contenir avec précision. Ce guide explique pourquoi BigInt existe, comment le créer et l'utiliser, dans quels domaines il excelle (finance, cryptographie, calcul à grande échelle), et les pièges à éviter.

Pourquoi BigInt existe

Le type Number en JavaScript est une valeur flottante 64 bits. Il ne peut représenter les entiers avec exactitude que jusqu'à Number.MAX_SAFE_INTEGER, soit 2^53 - 1 (9007199254740991). Au-delà, l'arithmétique ordinaire perd silencieusement de la précision :

javascript— editable

Lorsque vous avez besoin d'entiers exacts plus grands que cette limite — des identifiants issus d'une base de données, des montants en unités minimales, des clés cryptographiques, des factorielles — BigInt est la solution.

Comprendre BigInt en JavaScript

Un BigInt est un type primitif distinct de Number. L'opérateur typeof renvoie "bigint", et il possède ses propres règles arithmétiques.

Syntaxe et création

Créez un BigInt en ajoutant n à la fin d'un littéral entier, ou en appelant la fonction BigInt() sur un nombre ou une chaîne de caractères.

javascript— editable

Utilisez la forme string lorsque la valeur provient d'une saisie utilisateur ou dépasse ce qu'un littéral numérique peut exprimer avec précision. Passer un nombre non entier (comme BigInt(1.5)) lève une RangeError.

Opérations de base avec BigInt

BigInt prend en charge les mêmes opérateurs arithmétiques que Number, mais les deux opérandes doivent être de type BigInt. La division tronque vers zéro — il n'y a pas de partie fractionnaire.

javascript— editable

Notez que first / second vaut 2n, et non 2.5 — la division avec BigInt supprime le reste plutôt que de produire une fraction.

Comparer BigInt et Number

Même s'ils sont de types différents, BigInt et Number peuvent être comparés avec les opérateurs relationnels et l'opérateur d'égalité lâche ==. Seule l'égalité stricte === distingue les types, car elle vérifie également le type.

javascript— editable

Consultez les opérateurs de comparaison pour comprendre en général comment == et === diffèrent.

Limitations et conversion de type

Bien que puissant, BigInt présente des limitations spécifiques par rapport au type Number standard :

Pas de coercition implicite en arithmétique : Vous ne pouvez pas additionner, multiplier, etc. un BigInt et un Number ensemble — cela lève une TypeError. Convertissez d'abord l'un des deux.
Fonctions Math : Les méthodes Math standard (par exemple Math.sqrt(), Math.floor()) n'acceptent pas les arguments BigInt et lèveront une erreur.
Pas de plus unaire : +10n lève une erreur — utilisez plutôt Number(10n).
JSON : JSON.stringify ne peut pas sérialiser un BigInt et lève une TypeError ; convertissez-le d'abord en string vous-même.
Conversion explicite : Convertissez entre les types avec Number(bigint) ou BigInt(number). La conversion vers Number peut perdre de la précision pour de très grandes valeurs.

javascript— editable

Applications pratiques de BigInt

La capacité de BigInt à traiter de grands nombres avec précision le rend indispensable dans les calculs financiers, la cryptographie et le calcul à grande échelle.

Calculs financiers

Dans les applications financières, BigInt aide à éviter les erreurs d'arrondi associées aux nombres en virgule flottante.

javascript— editable

Cet exemple illustre l'utilisation de BigInt pour une arithmétique haute précision dans les contextes financiers, garantissant l'exactitude des transactions.

Info

BigInt est un outil essentiel en cryptographie, jouant un rôle crucial dans la génération de grands nombres premiers. Ces nombres sont fondamentaux pour les mécanismes de sécurité des algorithmes de chiffrement, garantissant une protection efficace des données.

Calcul haute performance

L'exemple suivant illustre l'utilisation de BigInt dans la multiplication de matrices pour le traitement de données à grande échelle, garantissant précision et efficacité. Nous inclurons une implémentation complète de la fonction de multiplication matricielle utilisant BigInt. Cela implique d'initialiser des matrices, de les remplir avec des valeurs BigInt, puis d'effectuer la multiplication. Voici un exemple réel étape par étape :

Étape 1 : Initialiser la matrice

D'abord, nous créons une fonction pour initialiser une matrice de dimensions données avec des zéros BigInt.

function initializeMatrix(rows, cols) {
  let matrix = new Array(rows);
  for (let i = 0; i < rows; i++) {
    matrix[i] = new Array(cols).fill(0n);
  }
  return matrix;
}

Étape 2 : Fonction de multiplication matricielle

Ensuite, nous définissons la fonction pour effectuer la multiplication de matrices. Les deux matrices d'entrée doivent contenir des valeurs BigInt, et la matrice résultante contiendra également des valeurs BigInt.

function multiplyMatrices(matrixA, matrixB) {
  if (matrixA[0].length !== matrixB.length) {
    throw new Error('Number of columns in Matrix A must equal number of rows in Matrix B');
  }

  let resultMatrix = initializeMatrix(matrixA.length, matrixB[0].length);

  for (let i = 0; i < matrixA.length; i++) {
    for (let j = 0; j < matrixB[0].length; j++) {
      let sum = 0n;
      for (let k = 0; k < matrixA[0].length; k++) {
        sum += matrixA[i][k] * matrixB[k][j];
      }
      resultMatrix[i][j] = sum;
    }
  }
  return resultMatrix;
}

Étape 3 : Matrices exemples et multiplication

Enfin, nous créons quelques matrices exemples et effectuons la multiplication. Les matrices sont remplies de valeurs BigInt.

javascript— editable

// Function to initialize a matrix with zeros (BigInt format)
function initializeMatrix(rows, cols) {
  let matrix = new Array(rows);
  for (let i = 0; i < rows; i++) {
    matrix[i] = new Array(cols).fill(0n); // Fill with BigInt zero
  }
  return matrix;
}

// Function to multiply two matrices that contain BigInt values
function multiplyMatrices(matrixA, matrixB) {
  if (matrixA[0].length !== matrixB.length) {
    throw new Error('The number of columns in Matrix A must be equal to the number of rows in Matrix B.');
  }

let resultMatrix = initializeMatrix(matrixA.length, matrixB[0].length);

for (let i = 0; i < matrixA.length; i++) {
    for (let j = 0; j < matrixB[0].length; j++) {
      let sum = 0n; // Start sum at BigInt zero
      for (let k = 0; k < matrixA[0].length; k++) {
        sum += matrixA[i][k] * matrixB[k][j]; // Add product of corresponding elements
      }
      resultMatrix[i][j] = sum; // Assign sum to the current position in result matrix
    }
  }
  return resultMatrix;
}

// Example matrices filled with BigInt values
let matrixA = [
  [1n, 2n],
  [3n, 4n]
];

let matrixB = [
  [2n, 0n],
  [1n, 2n]
];

// Perform matrix multiplication
let result = multiplyMatrices(matrixA, matrixB);

// Output the matrices by converting BigInt values to strings
console.log('Matrix A:', matrixA.map(row => row.map(value => `${value}n`)));
console.log('Matrix B:', matrixB.map(row => row.map(value => `${value}n`)));
console.log('Result of Multiplication:', result.map(row => row.map(value => `${value}n`)));

Explication du résultat

Cet exemple multiplie deux matrices 2x2 remplies de BigInts. Le résultat sera une nouvelle matrice où chaque élément est le résultat des règles de multiplication matricielle appliquées aux valeurs BigInt. Voici à quoi ressemble la multiplication :

Result[0][0] = (1n * 2n) + (2n * 1n) = 2n + 2n = 4n
Result[0][1] = (1n * 0n) + (2n * 2n) = 0n + 4n = 4n
Result[1][0] = (3n * 2n) + (4n * 1n) = 6n + 4n = 10n
Result[1][1] = (3n * 0n) + (4n * 2n) = 0n + 8n = 8n

Cette fonctionnalité démontre comment BigInt peut être utilisé pour gérer de grands nombres dans des calculs complexes comme la multiplication matricielle, garantissant précision et performance dans les applications JavaScript nécessitant des calculs numériques à grande échelle.

Avertissement

Utilisez BigInt avec discernement car il peut avoir un impact sur les performances en raison de ses besoins plus élevés en mémoire et en traitement par rapport aux nombres standard. Ne l'utilisez que lorsque c'est nécessaire pour manipuler de très grands entiers.

Bonnes pratiques pour utiliser BigInt en JavaScript

Lorsque vous intégrez BigInt dans vos projets JavaScript, tenez compte des bonnes pratiques suivantes pour optimiser les performances et la maintenabilité :

Types de données cohérents : Évitez de mélanger BigInt avec d'autres types numériques. La coercition entre BigInt et Number peut entraîner des erreurs ou un comportement inattendu. Assurez-vous que tous les opérandes des calculs sont de type BigInt lorsque nécessaire.
Pertinence du cas d'usage : Utilisez BigInt uniquement pour les nombres en dehors de la plage sûre des nombres JavaScript standard. Un usage excessif de BigInt peut entraîner une surcharge des performances.
Considérations mémoire : Bien que BigInt puisse gérer de très grands nombres, soyez attentif à l'utilisation de la mémoire dans vos applications, notamment dans les environnements aux ressources limitées.
Vérification de la compatibilité : Avant d'utiliser BigInt, vérifiez la compatibilité avec l'environnement JavaScript cible, car les navigateurs plus anciens ou certains moteurs JavaScript pourraient ne pas le prendre en charge.
Algorithmes efficaces : Lors d'opérations avec BigInt, notamment dans des boucles ou des fonctions récursives, optimisez vos algorithmes pour minimiser l'impact sur les performances.

Comprendre les polyfills pour BigInt en JavaScript

Le type BigInt de JavaScript est essentiel pour manipuler de très grands entiers, mais il n'est pas pris en charge dans tous les environnements. Pour assurer la compatibilité entre différents navigateurs et moteurs JavaScript, notamment les plus anciens, l'utilisation d'un polyfill pour BigInt peut être une approche pragmatique.

Qu'est-ce que le polyfilling ?

Le polyfilling est une technique utilisée pour implémenter des fonctionnalités dans des navigateurs web qui ne les prennent pas en charge nativement. Il s'agit d'inclure un script qui ajoute la fonctionnalité manquante à l'environnement JavaScript du navigateur, permettant aux développeurs d'utiliser des fonctionnalités modernes sans attendre que tous les utilisateurs passent à des navigateurs les supportant.

Polyfiller BigInt

Comme BigInt est un ajout relativement récent à JavaScript, tous les environnements ne le supportent pas. Le polyfilling vous permet d'utiliser BigInt dans ces environnements non pris en charge en simulant ses fonctionnalités. Cela peut être crucial pour les applications nécessitant des calculs haute précision dans des environnements où la mise à jour vers la dernière version du navigateur n'est pas possible.

Implémenter un polyfill BigInt

Implémenter un polyfill BigInt consiste à créer ou inclure une bibliothèque qui imite le comportement de BigInt. Voici une démonstration conceptuelle simple de la structure d'un wrapper de polyfill :

// Conceptual demonstration only. A true BigInt polyfill is complex and impractical.
// This example uses Number conversion internally for simplicity and is not suitable 
// for production large-integer handling.
if (typeof BigInt === "undefined") {
    window.BigInt = function(value) {
        return {
            value: value,
            toString: function() { return value + "n"; },
            add: function(other) { return BigInt(Number(this.value) + Number(other.value)); },
            subtract: function(other) { return BigInt(Number(this.value) - Number(other.value)); }
        };
    };
}

Limitations du polyfilling de BigInt

Bien que les polyfills puissent assurer la rétrocompatibilité, ils ne remplacent pas parfaitement les implémentations natives :

Performance : Les polyfills ne peuvent pas égaler les performances des opérations BigInt natives car ils sont implémentés en JavaScript plutôt que dans du code de bas niveau optimisé par les éditeurs de navigateurs.
Complexité : Reproduire fidèlement tous les aspects d'une fonctionnalité complexe comme BigInt peut s'avérer difficile et peut conduire à des bugs ou des incohérences.
Maintenance : Maintenir le polyfill à jour avec toute modification de la spécification officielle de BigInt nécessite un effort continu.

Info

Envisagez d'utiliser un polyfill BigInt pour assurer la compatibilité avec les navigateurs plus anciens qui ne supportent pas BigInt nativement. Cependant, sachez que les polyfills peuvent ne pas offrir les mêmes performances que les implémentations natives et doivent être utilisés comme solution temporaire jusqu'à ce que le support natif soit plus universellement disponible.

Conclusion

BigInt permet à JavaScript de représenter des entiers de toute taille avec une précision exacte, comblant la lacune laissée par la limite d'entiers sûrs à 53 bits du type Number. Recourez-y chaque fois qu'un entier risque de dépasser Number.MAX_SAFE_INTEGER — grands identifiants de base de données, montants en unités mineures, valeurs cryptographiques et calculs sur de grands nombres — mais gardez Number pour les calculs courants où les fractions et les méthodes Math sont nécessaires. Retenez la règle fondamentale : ne jamais mélanger BigInt et Number dans une opération arithmétique sans conversion explicite.

Sujets connexes

JavaScript Numbers — le type numérique standard et sa limite d'entiers sûrs.
JavaScript Math — les helpers mathématiques (qui fonctionnent sur Number, pas sur BigInt).
JavaScript Data Types — la place de bigint parmi les primitives.
Comparison Operators — le comportement de == et === abordé ci-dessus.

Pratique

Quelle est la bonne façon de créer un BigInt en JavaScript ?

En ajoutant un 'n' à la fin de l'entier.En ajoutant un 'b' à la fin de l'entier.En utilisant la fonction Big().En utilisant la fonction BigInt().