Collections à clé

Vous pouvez utiliser des littéraux d'objet pour stocker des paires clé/valeur et des tableaux pour stocker des collections de valeurs itérables. ES6 introduit également des structures de données spécialisées adaptées à des cas d'utilisation plus précis : "Mapper des paires clé/valeur" et "Définir" pour des valeurs individuelles.

Map

Un objet Map est une structure de données itérable qui stocke les informations sous forme de paires clé/valeur, semblables à un littéral d'objet. Contrairement aux littéraux d'objet, une carte permet à la fois aux valeurs et aux clés d'avoir n'importe quel type de données. Les éléments d'ordre ajoutés à une carte sont conservés lors de l'itération.

Pour créer une carte, utilisez le constructeur Map():

const myMap = new Map();

myMap;
> Map(0)

Vous pouvez préremplir une carte avec des données à l'aide d'une syntaxe ressemblant à un tableau (ou à n'importe quel objet itérateur) contenant des objets de type tableau composés de deux éléments. Le premier élément de chacune de ces structures de données à deux éléments devient la clé, tandis que le second devient la valeur associée à cette clé. La forme la plus simple est, en fait, un tableau dans lequel chaque élément est lui-même un tableau composé de deux éléments, la clé et la valeur de l'élément à ajouter à la carte:

const myMap = new Map([
    [ "myKey", "A string value" ],
    [ "mySecondKey", 500 ],
    [ "myThirdKey", true ]
]);

myMap;
> Map(3) {'myKey' => 'A string value', 'mySecondKey' => 500, 'myThirdKey' => true}

Là encore, un objet Map diffère d'un littéral d'objet en ce sens que les valeurs et les clés peuvent utiliser n'importe quel type de données et n'importe quelle valeur:

const notAFunction = () => console.log( "function" );
const myMap = new Map([
  [ null, 0 ],
  [ false, "This is false" ],
  [ undefined, "No defined value" ],
  [ NaN, "Not a number" ]
]);

myMap;
> Map(4) {null => 0, false => 'This is false', undefined => 'No defined value', NaN => 'Not a number'}

Pour obtenir, définir ou supprimer des éléments Map, utilisez les méthodes héritées du constructeur Map:

const myMap = new Map();

myMap;
> Map(0)

myMap.set( "myKey", "My value." );

myMap.has( "myKey" );
> true

myMap.get( "myKey" );
"My value."

myMap.delete( "myKey" );

myMap;
> Map(0)

Les clés d'un objet Map sont uniques, ce qui signifie que la définition d'une clé identique écrase la paire clé-valeur stockée précédemment:

const myMap = new Map([ [ "myKey", "A string value" ] ]);

myMap.set( "myKey", 500 );

myMap;
> Map(1) {'myKey' => 500}

Comme pour les objets, vous pouvez attribuer un élément Map à une variable déclarée avec const, puis le modifier. Toutefois, comme pour les autres cas d'utilisation de const, vous ne pouvez pas modifier ni supprimer la variable elle-même:

const myMap = new Map();
myMap.set( "myKey", "A string value" );

myMap;
> Map(1) {'myKey' => 500}

WeakMap

Une WeakMap est une carte qui contient des references "faibles", qui doivent être des références à des objets ou à des symboles qui n'ont pas été ajoutés au registre global des symboles.

Pour créer une WeakMap, utilisez le constructeur WeakMap():

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

La syntaxe WeakMap est semblable à celle de Map, mais les WeakMaps ne sont pas itérables. Si vous essayez d'utiliser une valeur autre qu'un objet ou un symbole comme clé, cela entraîne une erreur de syntaxe. Lorsqu'il n'existe aucune references à une clé en dehors de WeakMap, cet objet ou symbole, ainsi que la valeur associée dans WeakMap, sont tous deux éligibles à la récupération de mémoire.

Cela permet des cas d'utilisation tels que le stockage des métadonnées associées à un objet dans une WeakMap, en utilisant la référence à l'objet comme clé. Si cet objet est supprimé de la mémoire et qu'il n'existe aucune autre référence, les métadonnées associées sont également supprimées.

Jeu de

Un ensemble est une collection itérable de valeurs uniques quelque peu semblables à un tableau, bien qu'un ensemble ne puisse contenir que des valeurs uniques. Comme pour une carte, l'itération sur un ensemble conserve les éléments d'ordre qui lui ont été ajoutés.

Pour créer un Set, utilisez le constructeur Set():

const mySet = new Set();

mySet;
> Set []

Vous pouvez également créer un ensemble à partir d'un littéral de tableau:

const mySet = new Set([ 1, 2, 3 ]);

mySet;
> Set(3) [ 1, 2, 3 ]

Étant donné qu'un ensemble n'autorise pas les éléments en double, lorsqu'il est créé à partir d'un tableau contenant plusieurs instances de la même valeur, il ne conserve que la première instance de cette valeur:

const mySet = new Set([ 1, 2, 3, 2 ]);

mySet;
> Set(3) [ 1, 2, 3 ]

Pour ajouter ou supprimer des éléments d'un ensemble, utilisez les méthodes héritées du constructeur Set. Ces méthodes agissent sur un élément en fonction de sa valeur, au lieu de référencer un indice:

const mySet = new Set();

mySet.add( "My value." );

mySet;
> Set [ "My value." ]

mySet.has( "My value." );
> true

mySet.delete( "My value." );

mySet;
> Set []

Bien que les ensembles ne soient pas des collections indexées et qu'ils ne soient pas destinés à être utilisés tels quels, leurs éléments sont itérés par ordre d'insertion. Toute tentative d'ajout d'une valeur d'élément en double à un Set est ignorée, ce qui préserve l'ordre d'insertion d'origine:

const mySet = new Set([ 1, 2, 3 ]);

mySet;
> Set(3) [ 1, 2, 3 ]

mySet.add( 2 );
> Set(3) [ 1, 2, 3 ]

Pour créer un tableau à partir d'un ensemble, utilisez la méthode Array.from() ou la syntaxe de répartition:

const mySet = new Set([ 1, 2, 3 ]);
const myArray = Array.from( mySet );

myArray;
> Array(3) [ 1, 2, 3 ]

[ ...mySet ];
> Array(3) [ 1, 2, 3 ]

WeakSet

"WeakSet" est un ensemble qui ne contient que des valeurs pouvant être récupérées, telles que des références à des objets ou des symboles qui n'ont pas été ajoutés au registre de symboles global.

Pour créer un WeakSet, utilisez le constructeur WeakSet():

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

La syntaxe WeakSet est semblable à celle de Set, bien qu'un WeakSet ne soit pas itérable. Essayer d'ajouter une valeur autre qu'un objet ou un symbole entraîne une erreur de syntaxe. Comme pour WeakMap, lorsqu'il n'existe aucune autre references à une valeur référencée par un WeakSet, cette valeur devient éligible à la récupération de mémoire.

Cela permet des cas d'utilisation tels que l'agrégation d'une seule collection itérable d'objets associés. S'il n'existe aucune autre référence à un objet référencé par le WeakSet, l'élément associé est également supprimé.

Testez vos connaissances

        const myMap = new Map([ [ "myKey", "My string" ] ]);
        myMap.set( "myKey", 100 );