Sammlungen mit Schlüssel

Sie können Objektliterale zum Speichern von Schlüssel/Wert-Paaren und Arrays zum Speichern von iterierbare Sammlungen von Werten. ES6 führt außerdem spezialisierte Datenstrukturen für detailliertere Anwendungsfälle: Zuordnung für Schlüssel/Wert-Paare und Festlegen für individuelle Werte.

Karte

Eine Zuordnung ist eine iterierbare Datenstruktur, die Informationen als Schlüssel/Wert-Paare speichert, ähnlich einem Objektliteral. Im Gegensatz zu Objektliteralen lässt eine Map beide Werte zu und Schlüssel für einen beliebigen Datentyp und die Reihenfolgenelemente werden einer Map beibehalten werden.

Verwenden Sie den Map()-Konstruktor, um eine Karte zu erstellen:

const myMap = new Map();

myMap;
> Map(0)

Sie können eine Karte mithilfe einer Syntax, die einem Array ähnelt (oder ein beliebiges Iterator-Objekt), das Array-ähnliche Objekte, die aus zwei Elementen bestehen. Das erste Element in jeder dieser Datenstrukturen aus zwei Elementen werden zum Schlüssel, während die zweite zum Wert die mit diesem Schlüssel verknüpft sind. Die einfachste Form ist praktisch ein Array in Dabei ist jedes Element selbst ein Array, das aus zwei Elementen besteht, dem Schlüssel und dem -Wert des Elements, das zur Karte hinzugefügt werden soll:

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

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

Ein Map-Objekt unterscheidet sich wieder von einem Objektliteral, da beide Werte und die Schlüssel können einen beliebigen Datentyp und Wert annehmen:

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'}

Verwende zum Abrufen, Festlegen oder Löschen von „Map“-Elementen die von Map übernommenen Methoden -Konstruktor:

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)

Keys in einer Map sind eindeutig, d. h. wenn ein identischer Schlüssel festgelegt wird, Zuvor gespeichertes Schlüssel/Wert-Paar:

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

myMap.set( "myKey", 500 );

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

Wie bei Objekten können Sie einer mit const deklarierten Variablen eine Karte zuweisen. und ändere diese Karte. Wie bei anderen Anwendungsfällen für const können Sie Ändern oder löschen Sie die Variable selbst:

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

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

WeakMap

Eine WeakMap ist eine Karte, Referenzen, die Verweise auf Objekte oder Symbole sein müssen die noch nicht zur globalen Symbol-Registry hinzugefügt wurden.

Verwenden Sie den WeakMap()-Konstruktor, um eine WeakMap zu erstellen:

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

Die WeakMap-Syntax ähnelt der Map, WeakMaps jedoch nicht iterable [iterable] und versucht, Jeder Wert außer einem Objekt oder Symbol als Schlüssel führt zu einem Syntaxfehler. Wenn keine Verweise auf einen Schlüssel existieren WeakMap-Objekts und -Symbols sowie den zugehörigen Wert in der WeakMap, sind beide für die automatische Speicherbereinigung berechtigt.

Dies ermöglicht Anwendungsfälle wie das Speichern von Metadaten, die mit einem Objekt in Eine WeakMap, wobei der Verweis auf das -Objekt als Schlüssel verwendet wird. Wenn keine anderen Verweise für dieses Objekt existieren und das Objekt aus dem Arbeitsspeicher entfernt wird, werden ebenfalls entfernt.

Zeichensatz

Ein Set ist eine iterierbare Sammlung eindeutiger Werte, die einem Array ähnlich ist. Ein Set kann allerdings nur eindeutige Werte enthalten. Wie bei einer Karte kann die Iteration über eine Mit „set“ wird die Reihenfolge beibehalten, zu der Elemente hinzugefügt wurden.

Verwenden Sie den Konstruktor Set(), um ein Set zu erstellen:

const mySet = new Set();

mySet;
> Set []

Sie können auch ein Set aus einem Arrayliteral erstellen:

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

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

Da bei einem Set keine doppelten Elemente zulässig sind, wird ein Set aus einem ein Array aus mehreren Instanzen desselben Werts enthält, wird nur die erste beibehalten. Instanz dieses Werts:

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

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

Wenn Sie Elemente zu einem Set hinzufügen oder daraus entfernen möchten, verwenden Sie die von Set übernommenen Methoden -Konstruktor. Diese Methoden wirken sich auf ein Element basierend auf dem Wert des Elements aus anstatt auf einen Index zu verweisen:

const mySet = new Set();

mySet.add( "My value." );

mySet;
> Set [ "My value." ]

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

mySet.delete( "My value." );

mySet;
> Set []

Sets sind keine indexierten Sammlungen und sind nicht zur Verwendung werden die Elemente in einem Set über und zwar in der richtigen Reihenfolge. Versuche, einem Set einen doppelten Elementwert hinzuzufügen, sind übersprungen und der ursprüngliche Anzeigenauftrag beibehalten:

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

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

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

Verwenden Sie zum Erstellen eines Arrays aus einem Set entweder die Methode Array.from() oder Verteilung Syntax:

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 ist ein Set, das nur Werte für die automatische Speicherbereinigung enthält. z. B. Verweise auf Objekte oder Symbole die noch nicht zur globalen Symbol-Registry hinzugefügt wurden.

Verwenden Sie den WeakSet()-Konstruktor, um ein WeakSet zu erstellen:

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

Die WeakSet-Syntax ähnelt Set, obwohl ein WeakSet nicht iterable und der Versuch, Jeder Wert außer einem Objekt oder Symbol verursacht einen Syntaxfehler. Wie bei WeakMap wenn keine anderen Verweise auf ein Wert, auf den ein WeakSet verweist, vorhanden ist, kann dieser Wert für automatische Speicherbereinigung.

Dies ermöglicht Anwendungsfälle wie das Aggregieren einer einzelnen, iterierbaren Sammlung von verwandten Objekte. Wenn keine anderen Verweise auf ein Objekt vorhanden sind, auf das im WeakSet enthält, wird das zugehörige Element ebenfalls aus WeakSet entfernt.

Wissen testen

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