Map & Set

Un Map est une collection de paires clé-valeur où les clés peuvent être de n'importe quel type — objets, fonctions, primitives, même NaN. C'est un avantage majeur par rapport aux objets simples, où les clés sont toujours converties en chaînes de caractères.

Créer et utiliser un Map :

const map = new Map();

// Définir des valeurs
map.set('name', 'Alice');
map.set(42, 'the answer');
map.set(true, 'yes');

// Récupérer des valeurs
console.log(map.get('name')); // 'Alice'
console.log(map.get(42));     // 'the answer'

// Vérifier l'existence
console.log(map.has('name')); // true
console.log(map.has('age'));  // false

// Taille
console.log(map.size); // 3

// Supprimer
map.delete(42);
console.log(map.size); // 2

// Vider toutes les entrées
map.clear();
console.log(map.size); // 0

Tu peux aussi initialiser un Map avec un tableau de paires [clé, valeur] :

const map = new Map([
  ['name', 'Alice'],
  ['age', 30],
  ['city', 'Paris']
]);

Quand utiliser Map plutôt qu'un objet :

• Les clés ne sont pas des chaînes de caractères (nombres, objets, etc.).
• Tu as besoin de connaître facilement la taille (.size).
• Tu as besoin d'ajouts et de suppressions fréquents.
• Tu as besoin d'un ordre d'insertion garanti pendant l'itération.

Les Maps sont itérables et fournissent plusieurs méthodes pour accéder à leur contenu.

Méthodes d'itération :

const map = new Map([
  ['a', 1],
  ['b', 2],
  ['c', 3]
]);

// Clés
for (const key of map.keys()) {
  console.log(key); // 'a', 'b', 'c'
}

// Valeurs
for (const value of map.values()) {
  console.log(value); // 1, 2, 3
}

// Entrées (paires clé-valeur)
for (const [key, value] of map.entries()) {
  console.log(key, value); // 'a' 1, 'b' 2, 'c' 3
}

for...of avec déstructuration — itérer directement sur un Map te donne les entrées :

for (const [key, value] of map) {
  console.log(`${key} => ${value}`);
}

Méthode forEach :

map.forEach((value, key) => {
  console.log(`${key}: ${value}`);
});

Convertir entre Maps et tableaux :

// Map vers tableau d'entrées
const entries = [...map]; // [['a', 1], ['b', 2], ['c', 3]]

// Tableau d'entrées vers Map
const newMap = new Map(entries);

// Clés du Map vers tableau
const keys = [...map.keys()]; // ['a', 'b', 'c']

Un Set est une collection de valeurs uniques. Si tu essaies d'ajouter une valeur qui existe déjà, elle est simplement ignorée.

Créer et utiliser un Set :

const set = new Set();

// Ajouter des valeurs
set.add(1);
set.add(2);
set.add(3);
set.add(2); // Ignoré — 2 existe déjà

console.log(set.size); // 3

// Vérifier l'existence
console.log(set.has(2)); // true
console.log(set.has(4)); // false

// Supprimer
set.delete(2);
console.log(set.size); // 2

// Vider
set.clear();

Le cas d'usage le plus courant — supprimer les doublons d'un tableau :

const numbers = [1, 2, 3, 2, 4, 3, 5, 1];
const unique = [...new Set(numbers)];
console.log(unique); // [1, 2, 3, 4, 5]

Les Sets sont aussi itérables :

const set = new Set(['apple', 'banana', 'cherry']);

for (const fruit of set) {
  console.log(fruit);
}

set.forEach(value => console.log(value));

const array = [...set]; // Convertir en tableau

Les Sets utilisent l'égalité stricte (===) pour la comparaison, avec le cas spécial que NaN est égal à NaN dans un Set (contrairement au === normal).

JavaScript fournit également WeakMap et WeakSet — des versions spécialisées de Map et Set avec des différences importantes.

Restrictions clés :

• Les clés de WeakMap doivent être des objets (pas de primitives).
• Les valeurs de WeakSet doivent être des objets.

Références faibles :

Le "weak" (faible) dans WeakMap/WeakSet signifie que les références aux clés (ou valeurs) sont maintenues faiblement. S'il n'y a pas d'autres références à l'objet clé, il peut être collecté par le ramasse-miettes — même s'il est toujours dans le WeakMap.

let user = { name: 'Alice' };
const cache = new WeakMap();
cache.set(user, 'cached data');

user = null; // L'objet { name: 'Alice' } peut maintenant être collecté par le ramasse-miettes

Pas de méthodes d'itération — tu ne peux pas itérer sur un WeakMap ou WeakSet. Ils n'ont pas de .size, .keys(), .values(), .entries(), ou .forEach(). C'est parce que les entrées peuvent disparaître à tout moment en raison de la collecte des déchets.

Cas d'usage courants :

• Données privées — stocker des propriétés privées associées à des objets.
• Mise en cache — mettre en cache des valeurs calculées sans empêcher la collecte des déchets.
• Métadonnées de nœuds DOM — attacher des données à des éléments DOM qui sont nettoyées quand l'élément est supprimé.

const metadata = new WeakMap();

function processElement(el) {
  if (!metadata.has(el)) {
    metadata.set(el, { visits: 0 });
  }
  metadata.get(el).visits++;
}