Collections à clé

Vous pouvez utiliser des littéraux d'objet pour stocker des paires clé/valeur, et des tableaux pour stocker et itérables de valeurs. ES6 présente également des structures de données spécialisées pour répondre à des cas d'utilisation plus précis: Mappez pour des paires clé-valeur et Définir pour des valeurs individuelles.

Carte

Un Map est une structure de données itérable qui stocke les informations sous forme de paires clé-valeur, comme un littéral d'objet. Contrairement aux littéraux d'objet, un objet Map autorise les deux valeurs et clés de n'importe quel type de données, et que les éléments d'ordre sont ajoutés à une Map préservées lors des itérations.

Pour créer un élément Map, utilisez le constructeur Map():

const myMap = new Map();

myMap;
> Map(0)

Vous pouvez préremplir une carte avec des données en utilisant une syntaxe qui ressemble à un tableau (ou tout objet itérateur) contenant objets de type tableau constitués de deux éléments. Le premier élément de chacun de ces les structures de données à deux éléments deviennent la clé, tandis que la seconde devient la valeur associées à cette clé. La forme la plus simple de ceci est, en fait, un tableau dans chaque élément étant lui-même un tableau composé de deux éléments : la clé et le 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 dans la mesure où les deux valeurs et les clés peuvent accepter 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 Map. constructeur:

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 mappage sont uniques, ce qui signifie que la définition d'une clé identique remplace la clé-valeur précédemment stockée:

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

myMap.set( "myKey", 500 );

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

Comme pour les objets, vous pouvez affecter un mappage à une variable déclarée avec const et puis modifiez cette carte. Toutefois, comme pour d'autres cas d'utilisation de const, vous ne pouvez pas modifier ou 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 le mot "faible" références qui doivent faire référence à des objets ou à des symboles qui n'ont pas été ajoutés au registre global des symboles.

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

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

La syntaxe de WeakMap est semblable à celle de Map, mais WeakMaps ne le sont pas. iterable et essayer d'utiliser toute valeur autre qu'un objet ou un symbole comme clé entraîne une erreur de syntaxe. Si aucune références à une clé en dehors de WeakMap, de cet objet ou de ce symbole, ainsi que de 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 un WeakMap en utilisant la référence à l'objet comme clé. Si aucune autre référence à cet objet et que celui-ci est supprimé de la mémoire, les informations les métadonnées sont également supprimées.

Jeu de

Un ensemble est une collection itérable de valeurs uniques, assez semblables à un tableau. même si un ensemble ne peut contenir que des valeurs uniques. Comme pour une carte, l'itération La règle Set conserve l'ordre dans lequel les éléments ont été ajoutés.

Pour créer un ensemble, 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'un ensemble est créé à partir d'un 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 dans un ensemble, utilisez les méthodes héritées du Set. d'un constructeur. Ces méthodes agissent sur un élément en fonction de sa valeur au lieu de référencer un index:

const mySet = new Set();

mySet.add( "My value." );

mySet;
> Set [ "My value." ]

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

mySet.delete( "My value." );

mySet;
> Set []

Toutefois, les ensembles ne sont pas des collections indexées et ne sont pas destinés à être utilisés c'est-à-dire que les éléments d'un ensemble sont itérés par ordre d'insertion. Les tentatives d'ajout d'une valeur d'élément en double à un ensemble sont ignorée, en conservant 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 soit la méthode Array.from(), soit la répartition syntaxe:

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 récupérables. comme des références à des objets ou à des symboles qui n'ont pas été ajoutés au registre global des symboles.

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

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

La syntaxe WeakSet est semblable à Set, bien qu'un WeakSet ne soit pas iterable, et essayer d'ajouter toute valeur autre qu'un objet ou un symbole provoque une erreur de syntaxe. Comme pour WeakMap, lorsqu'aucune autre référence à une valeur référencée par un WeakSet existe, cette valeur devient éligible pour la récupération de mémoire.

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

Testez vos connaissances

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