Collections avec clés

Ce chapitre présente les collections de données qui sont ordonnées avec une clé. Les objets Map et Set contiennent des éléments sur lesquels on peut itérer dans leur ordre d'insertion.

Maps

Le type Map

ECMAScript 6 introduit une nouvelle structure de données pour faire correspondre des données entre elle. Un objet Map représente une collection de données qui sont des correspondances entre des clés ou valeurs et pour lequel on peut itérer dans l'ordre d'insertion pour lister les différentes clés / valeurs.

Le code suivant illustre certaines opérations basiques avec Map. Pour plus d'informations sur cet objet, voir également la page de référence Map. Il est possible d'utiliser une boucle for...of pour renvoyer un tableau [clé, valeur] à chaque itération.

var sayings = new Map();
sayings.set("dog", "woof");
sayings.set("cat", "meow");
sayings.set("elephant", "toot");
sayings.size; // 3
sayings.get("fox"); // undefined
sayings.has("bird"); // false
sayings.delete("dog");

for (var [key, value] of sayings) {
  console.log(key + " goes " + value);
}
// "cat goes meow"
// "elephant goes toot"

Comparaison entre les types Object et Map

Habituellement, les objets objets ont été utilisés pour faire correspondre des chaînes avec des valeurs. Les objets permettent d'associer des clés avec des valeurs, de récupérer ces valeurs, de supprimer des clés, de détecter si quelque chose est enregistré dans une clé. Le type Map possède cependant certains avantages pour être utilisés comme maps.

• Les clés d'un objet de type Object sont des chaînes de caractères. Pour Map, une clé peut être une valeur de n'importe quel type.
• On peut simplement obtenir la taille d'un objet Map alors qu'il faut tenir compte manuellement du nombre de clés contenue dans un objet Object.
• Les itérations sur les maps se font dans l'ordre d'insertion des éléments.
• Un objet de type Object possède un prototype, il y a donc des clés par défaut déjà présentes dans l'objet. (cela peut être surchargé en utilisant map = Object.create(null)).

Pour savoir si on doit utiliser le type Map ou le type Object, on peut considérer les aspects suivants :

• On utilisera des maps plutôt que des objets lorsque les clés sont inconnues avant l'exécution et lorsque toutes les clés sont de même type et que les valeurs sont de même type.
• On utilisera des maps lorsque les clés peuvent être des valeurs primitives autres que des chaînes de caractères (en effet, les objets considèrent toutes leurs clés comme des chaînes en convertissant les valeurs).
• On utilisera des objets lorsqu'il y a une logique propre à des éléments individuels.

Le type WeakMap

L'objet WeakMap est une collection de paires clés/valeurs pour lesquelles les clés sont uniquement des objets (les valeurs peuvent être d'un type arbitraire). Les références vers les objets sont des références « faibles ». Cela signifie qu'elles seront collectées par le ramasse-miettes s'il n'y a pas d'autres références vers cet objet. L'API WeakMap offre les mêmes fonctionnalités que l'API Map.

La différence entre le type Map et le type WeakMap est que les clés d'un objet WeakMap ne sont pas énumérables (c'est-à-dire qu'on n'a pas de méthode pour donner la liste des clés). S'il en existait une, la liste dépendrait de l'état d'avancement du ramasse-miettes, ce qui introduirait un non-déterminisme.

Pour plus d'informations et d'exemples, voir également le paragraphe « Pourquoi WeakMap ? » sur l'article WeakMap de la référence.

Un cas d'utilisation des objets WeakMap est le stockage de données privées d'un objet ou pour cacher certains détails d'implémentation. L'exemple qui suit est tiré du billet de blog de Nick Fitzgerald « Masquer des détails d'implémentation avec les WeakMaps ECMAScript 6 ». Les données et méthodes privées sont stockées dans l'objet WeakMap privates. Tout ce qui est exposé par l'instance et le prototype est public. Tout ce qui est en dehors est inaccessible car privates n'est pas exporté depuis le module :

const privates = new WeakMap();

function Public() {
  const me = {
    // Les données privées ici
  };
  privates.set(this, me);
}

Public.prototype.method = function () {
  const me = privates.get(this);
  // On fait des choses avec les données privées dans `me`...
};

module.exports = Public;

Les ensembles

Le type Set

Les objets Set sont des ensembles de valeurs. Il est possible de les parcourir dans l'ordre d'insertion des éléments. Une valeur d'un élément Set ne peut y apparaître qu'une seule fois, il est unique pour cette instance de Set.

Le code suivant illustre certaines opérations basiques avec Set. Voir aussi la page Set sur  page for more examples and the complete API.

var monEnsemble = new Set();
monEnsemble.add(1);
monEnsemble.add("du texte");
monEnsemble.add("toto");

monEnsemble.has(1); // true
monEnsemble.delete("toto");
monEnsemble.size; // 2

for (let item of monEnsemble) console.log(item);
// 1
// "du texte"

Convertir des tableaux (Array) en ensembles (Set)

Il est possible de créer un Array à partir d'un Set grâce à Array.from ou l'opérateur de décomposition. Pour effectuer la conversion dans l'autre sens, on peut utiliser le constructeur Set avec un argument de type Array. Encore une fois, les objets Set stockent des valeurs uniques, les éléments dupliqués dans un tableau seront supprimés lors de la conversion.

Array.from(monSet);
[...monSet2];

monSet2 = new Set([1,2,3,4]);

Comparaison entre Array et Set

Historiquement, on représentait des ensembles avec des tableaux JavaScript. Ce nouveau type, Set, possède certains avantages :

• Lorsqu'on souhaite vérifier si un élément existe déjà dans un tableau, on est obligé d'utiliser indexOf ce qui peut diminuer les performances.
• Les objets Set permettent de supprimer les éléments avec leur valeur. Avec un tableau, il faudrait « découper » le tableau sur l'indice de l'élément.
• Dans un tableau, la valeur NaN ne peut pas être trouvée avec la méthode indexOf.
• Les objets Set permettent de stocker des valeurs uniques, il n'est pas nécessaire d'effectuer des vérifications manuellement.

Le type WeakSet

Les objets WeakSet sont des ensembles d'objets. Un objet d'un WeakSet ne peut y apparaître qu'une seule fois maximum. On ne peut pas itérer sur les objets WeakSet (ils ne sont pas énumérables).

Les principales différences avec l'objet Set sont :

• Contrairement aux objets Set, les objets WeakSet sont des ensembles qui ne comprennent que des objets, les valeurs ne peuvent pas être d'un type arbitraire.
• Les objets WeakSet utilisent des références faibles vers les objets. Ainsi, s'il n'y a pas d'autres références vers l'objet stocké dans le WeakSet, celui-ci pourra être collecté par le ramasse-miettes pour libérer de la mémoire. Cela signifie également qu'on ne peut pas maintenir une liste des différents objets contenus dans l'ensemble : les objets WeakSet ne sont pas énumérables.

Les cas d'utilisations pour les objets WeakSet objects sont relativement limités. Ils empêcheront toute fuite mémoire donc on pourra, de façon sécurisée, les utiliser avec des éléments DOM qui pourront être des clés (pour les utiliser par ailleurs, etc.).

Égalité des clés et des valeurs avec Map et Set

L'égalité utilisée pour les clés des objets Map et celle utilisée pour les valeurs des objets Set sont les mêmes : elles sont basées sur l'algorithme suivant :

• L'égalité fonctionne de la même façon qu'avec l'opérateur d'égalité stricte ===.
• -0 et +0 sont considérés égaux.
• NaN est considéré égal à lui-même (contrairement à ce qu'on obtient avec ===).