JavaScript Map et Set

Ce chapitre couvre deux collections à clés introduites dans le JavaScript moderne : Map (paires clé-valeur) et Set (valeurs uniques). Vous apprendrez ce qu'elles font, quand les utiliser plutôt que des objets et des tableaux ordinaires, comment les itérer, et les patterns que vous utiliserez vraiment au quotidien, comme la déduplication d'un array ou la construction d'un compteur de fréquences.

JavaScript Map

Une Map est une collection de paires clé-valeur, semblable à un object ordinaire — mais avec des différences importantes qui en font le meilleur choix dans de nombreuses situations.

Map vs. object ordinaire : quand utiliser une Map

Préférez une Map à un object ordinaire lorsque :

• Les clés ne sont pas des string. Les clés d'un object sont toujours converties en string (ou en symboles). Une Map vous permet d'utiliser n'importe quelle valeur comme clé : objects, fonctions, nombres, même NaN.
• Vous ajoutez et supprimez des entrées fréquemment. Les Maps sont optimisées pour les insertions et suppressions fréquentes, et map.size donne le nombre d'entrées directement (les objects ont besoin de Object.keys(obj).length).
• Vous avez besoin d'un ordre d'itération garanti. Une Map itère toujours dans l'ordre d'insertion.
• Vous voulez éviter les collisions de prototype. Un object ordinaire hérite de clés comme toString et constructor ; une Map n'a pas de telles clés intégrées, donc les clés fournies par l'utilisateur ne peuvent jamais entrer en conflit avec elles.

Utilisez un object ordinaire lorsque les données ont une forme fixe et connue (un enregistrement), ou lorsque vous avez besoin de la sérialisation JSON — JSON.stringify fonctionne sur les objects mais pas sur les Maps.

Créer et manipuler des Maps

Pour créer une Map, utilisez new Map(). Elle prend en charge ces méthodes et propriétés :

• map.set(key, value) : Ajoute ou met à jour une paire clé-valeur. Retourne la Map, les appels peuvent donc être chaînés.
• map.get(key) : Récupère la valeur associée à une clé (undefined si absente).
• map.has(key) : Retourne true si la clé existe.
• map.delete(key) : Supprime une paire clé-valeur.
• map.clear() : Supprime tout.
• map.size : Le nombre de paires clé-valeur.

Comme set() retourne la Map, vous pouvez chaîner les appels :

Utiliser n'importe quelle valeur comme clé

Contrairement aux objects, une Map conserve les clés telles quelles. Le nombre 1 et la string "1" sont des clés différentes, et des objects ou des fonctions peuvent être des clés (comparés par référence) :

Itérer sur une Map

Une Map itère dans l'ordre d'insertion et propose trois méthodes d'itérateur ainsi que forEach :

• map.keys() — un itérable de clés.
• map.values() — un itérable de valeurs.
• map.entries() — un itérable de paires [key, value] (c'est le comportement par défaut, donc for...of map fonctionne directement).
• map.forEach((value, key) => ...) — exécute un callback pour chaque entrée.

Convertir entre Map et object

Une Map peut être construite à partir des entrées d'un object et reconvertie en object :

JavaScript Set

Un Set est une collection de valeurs uniques — chaque valeur ne peut apparaître qu'une seule fois. Il est étroitement lié à un array, mais sans doublons ni accès par index.

Set vs. array : quand utiliser un Set

Préférez un Set à un array lorsque :

• L'unicité est importante. Un Set rejette automatiquement les doublons, vous n'avez donc jamais besoin de vérifier avant d'ajouter.
• Vous testez souvent l'appartenance. set.has(value) est rapide et lisible, tandis que array.includes(value) parcourt tout le array à chaque fois.

Restez avec un array lorsque vous avez besoin d'un accès par index, de doublons, ou de méthodes comme map/filter/reduce. (Vous pouvez toujours convertir entre les deux.)

Travailler avec les Sets

• new Set(iterable) : Crée un Set, optionnellement à partir d'un array ou de tout itérable.
• set.add(value) : Ajoute une valeur (retourne le Set, les appels peuvent donc être chaînés). Les doublons sont ignorés.
• set.has(value) : Retourne true si la valeur est présente.
• set.delete(value) : Supprime une valeur.
• set.size : Le nombre de valeurs.
• set.clear() : Supprime tout.

Dédupliquer un array (l'utilisation n°1)

La raison la plus courante d'utiliser un Set est de supprimer les doublons d'un array. Étalez le Set dans un array avec [...new Set(arr)] :

Itérer sur un Set

Les Sets itèrent dans l'ordre d'insertion et prennent en charge for...of et forEach :

Union, intersection et différence

Les Sets facilitent les opérations classiques sur les ensembles. Les moteurs modernes fournissent également des méthodes intégrées set.union(), set.intersection() et set.difference(), mais voici l'approche portable utilisant des arrays :

Un scénario réel : compteur de fréquences de mots

Cet exemple montre pourquoi une Map surpasse souvent un object ordinaire. Nous comptons combien de fois chaque mot apparaît dans une phrase. Avec une Map, les clés restent de vraies string, size est immédiat, et il n'y a aucun risque qu'un mot entre en collision avec un nom de propriété héritée :

Aide-mémoire des méthodes

Map

Set

Règle générale : utilisez une Map lorsque vous avez besoin de données à clés avec des clés non-string, de mises à jour fréquentes ou d'un ordre garanti ; utilisez un Set lorsque vous avez besoin d'une collection de valeurs uniques avec des vérifications d'appartenance rapides. Pour tout le reste, les objects et les arrays ordinaires restent les bons outils.

Pratique