Introduction

Les Map en JavaScript sont des structures de données puissantes qui permettent de stocker des paires clé-valeur. Contrairement aux objets classiques, les Maps préservent l'ordre d'insertion et peuvent utiliser n'importe quel type comme clé. Cependant, contrairement aux tableaux, les Maps ne disposent pas d'une méthode sort() intégrée. Dans cet article, nous allons explorer différentes techniques pour trier un Map en JavaScript, que ce soit par ses clés ou par ses valeurs.

Trier un Map par clés

La méthode la plus courante pour trier un Map par ses clés consiste à convertir le Map en tableau, le trier, puis créer un nouveau Map. Voici comment procéder :

// Créer un Map
const monMap = new Map([
  ['banane', 3],
  ['pomme', 5],
  ['cerise', 1],
  ['datte', 2]
]);

// Trier par clés (alphabétiquement)
const trieParCles = new Map(
  [...monMap.entries()].sort((a, b) => a[0].localeCompare(b[0]))
);

console.log(trieParCles);
// Map(4) { 'cerise' => 1, 'datte' => 2, 'banane' => 3, 'pomme' => 5 }

Explication

L'opérateur de décomposition [...monMap.entries()] convertit les entrées du Map en un tableau de paires [clé, valeur]. Nous trions ensuite ce tableau à l'aide de sort() avec une fonction de comparaison utilisant localeCompare() pour un tri alphabétique correct (qui prend en compte les accents et les caractères spéciaux), puis nous créons un nouveau Map à partir du tableau trié.

Trier un Map par valeurs

Pour trier par valeurs plutôt que par clés, nous modifions simplement la fonction de comparaison :

// Trier par valeurs (numériquement, croissant)
const trieParValeurs = new Map(
  [...monMap.entries()].sort((a, b) => a[1] - b[1])
);

console.log(trieParValeurs);
// Map(4) { 'cerise' => 1, 'datte' => 2, 'banane' => 3, 'pomme' => 5 }

// Trier par valeurs (décroissant)
const trieParValeursDesc = new Map(
  [...monMap.entries()].sort((a, b) => b[1] - a[1])
);

console.log(trieParValeursDesc);
// Map(4) { 'pomme' => 5, 'banane' => 3, 'datte' => 2, 'cerise' => 1 }

Créer une fonction réutilisable

Pour une meilleure organisation du code, vous pouvez créer une fonction utilitaire :

function trierMap(map, triPar = 'cle', ordre = 'croissant') {
  const entrees = [...map.entries()];
  
  const comparer = (a, b) => {
    const aVal = triPar === 'cle' ? a[0] : a[1];
    const bVal = triPar === 'cle' ? b[0] : b[1];
    
    // Pour les nombres
    if (typeof aVal === 'number' && typeof bVal === 'number') {
      return ordre === 'croissant' ? aVal - bVal : bVal - aVal;
    }
    
    // Pour les chaînes de caractères
    if (typeof aVal === 'string' && typeof bVal === 'string') {
      const resultat = aVal.localeCompare(bVal);
      return ordre === 'croissant' ? resultat : -resultat;
    }
    
    // Comparaison générique
    if (ordre === 'croissant') {
      return aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
    } else {
      return aVal > bVal ? -1 : aVal < bVal ? 1 : 0;
    }
  };
  
  return new Map(entrees.sort(comparer));
}

// Exemples d'utilisation
const trie1 = trierMap(monMap, 'cle', 'croissant');
const trie2 = trierMap(monMap, 'valeur', 'decroissant');

Cas d'usage pratiques

Voici quelques exemples concrets où le tri de Map est utile :

Trier des statistiques par valeur (scores, votes, etc.)
Organiser des données par ordre alphabétique de clés
Créer des classements ou des top listes

// Exemple : Classement des meilleurs scores
const scores = new Map([
  ['Alice', 95],
  ['Bob', 87],
  ['Charlie', 92],
  ['Diana', 88]
]);

// Trier par score décroissant pour obtenir le classement
const classement = new Map(
  [...scores.entries()].sort((a, b) => b[1] - a[1])
);

console.log(classement);
// Map(4) { 'Alice' => 95, 'Charlie' => 92, 'Diana' => 88, 'Bob' => 87 }

Performance et bonnes pratiques

Le tri d'un Map a une complexité temporelle de O(n log n) due à l'algorithme de tri. Pour de grandes quantités de données, considérez :

Mettre en cache les résultats triés si le Map ne change pas fréquemment
Utiliser une structure de données différente si le tri est une opération très fréquente
Évaluer paresseusement (lazy evaluation) pour de très grands datasets

Astuce : Si vous devez trier fréquemment, envisagez d'utiliser un tableau trié ou une structure de données spécialisée comme un SortedMap (disponible dans certaines bibliothèques).

Conclusion

Nous avons couvert les aspects essentiels du tri de Map en JavaScript. Bien que les Maps n'aient pas de méthode sort() intégrée, il est facile de les trier en les convertissant en tableaux. La pratique et l'expérimentation vous aideront à maîtriser ces concepts et à les appliquer efficacement dans vos projets.

N'hésitez pas à adapter ces exemples à vos besoins spécifiques et à explorer d'autres techniques de tri selon vos cas d'usage !

Comment trier un Map en JavaScript