Raccolte con chiave

Puoi usare i valori letterali oggetto per archiviare coppie chiave-valore e gli array per archiviare e iterabili di valori. ES6 introduce anche strutture di dati specializzate per i casi d'uso più granulari: Mappa le coppie chiave-valore e Imposta per i singoli valori.

Mappa

Una mappa è una struttura di dati iterabile che memorizza le informazioni sotto forma di coppie chiave-valore, in modo simile a un valore letterale Object. A differenza dei valori letterali oggetto, una mappa consente entrambi i valori e chiavi per avere qualsiasi tipo di dati e gli elementi dell'ordine vengono aggiunti a una mappa viene conservata durante l'iterazione.

Per creare una mappa, utilizza il costruttore Map():

const myMap = new Map();

myMap;
> Map(0)

Puoi precompilare una mappa con dati utilizzando una sintassi simile a quella di un array (oppure qualsiasi oggetto iteratore) contenente di oggetti di tipo array composti da due elementi. Il primo elemento di ciascuno di questi le strutture dati a due elementi diventano la chiave, mentre il secondo diventa il valore associati a quella chiave. La forma più semplice è, a tutti gli effetti, un array in cui ogni elemento è a sua volta un array composto da due elementi: la chiave e valore dell'elemento da aggiungere alla mappa:

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

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

Anche in questo caso, un oggetto Map differisce da un valore letterale oggetto in quanto entrambi i valori e le chiavi possono assumere qualsiasi tipo di dati e valore:

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

Per ottenere, impostare o eliminare gli elementi della mappa, utilizza i metodi ereditati dall'Map costruttore:

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)

Le chiavi in una mappa sono univoche, vale a dire che l'impostazione di una chiave identica sovrascrive i valori coppia chiave-valore precedentemente memorizzata:

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

myMap.set( "myKey", 500 );

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

Come per gli oggetti, puoi assegnare una mappa a una variabile dichiarata con const e e poi modificare la mappa. Tuttavia, come per altri casi d'uso di const, non puoi modificare o eliminare la variabile stessa:

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

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

WeakMap

Una WeakMap è una mappa contenente "debole" riferimenti, che devono essere riferimenti a oggetti o simboli che non sono state aggiunte al registro dei simboli globale.

Per creare una WeakMap, utilizza il costruttore WeakMap():

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

La sintassi di WeakMap è simile a quella di Map, ma non sono iterable e tentare di utilizzare qualsiasi valore diverso da un oggetto o un simbolo come chiave provoca un errore di sintassi. Se no esistono riferimenti a una chiave all'esterno della WeakMap, l'oggetto o il simbolo e il valore associato WeakMap, sono entrambi idonei per la garbage collection.

Ciò consente casi d'uso come l'archiviazione di metadati associati a un oggetto in una WeakMap, utilizzando il riferimento all'oggetto come chiave. Se non ci sono altri riferimenti e l'oggetto viene rimosso dalla memoria, l'oggetto associato vengono rimossi anche i metadati.

Configura

Un set è una raccolta iterabile di valori univoci, in qualche modo simile a un array, ma un insieme può contenere solo valori unici. Come per una mappa, ripetendo L'impostazione consente di mantenere gli elementi dell'ordine aggiunti.

Per creare un set, utilizza il costruttore Set():

const mySet = new Set();

mySet;
> Set []

Puoi anche creare un set da un valore letterale Array:

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

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

Poiché un insieme non consente elementi duplicati, quando un insieme viene creato da un a un array contenente più istanze dello stesso valore, conserva solo la prima istanza di quel valore:

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

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

Per aggiungere o rimuovere elementi da un insieme, utilizza i metodi ereditati dall'Set come costruttore. Questi metodi agiscono su un elemento in base al suo valore invece di fare riferimento a 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 []

Sebbene gli insiemi non siano raccolte indicizzate e non siano destinati a essere utilizzati come come gli elementi di un set, vengono iterati in ordine di inserimento. I tentativi di aggiungere un valore di elemento duplicato a un insieme sono ignorato, mantenendo l'ordine di inserzione originale:

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

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

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

Per creare un array da un insieme, utilizza il metodo Array.from() o la diffusione sintassi:

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 è un insieme che contiene solo valori garbage-collectable, come riferimenti agli oggetti o simboli che non sono state aggiunte al registro dei simboli globale.

Per creare un WeakSet, utilizza il costruttore WeakSet():

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

La sintassi WeakSet è simile a Set, anche se un WeakSet non è iterable e provare ad aggiungere qualsiasi valore diverso da un oggetto o un simbolo provoca un errore di sintassi. Come per WeakMap, quando nessun altro riferimento a esiste un valore a cui fa riferimento un WeakSet, tale valore diventa idoneo per garbage collection.

Ciò consente casi d'uso come l'aggregazione di un'unica raccolta iterabile di oggetti correlati. Se non esistono altri riferimenti a un oggetto a cui fa riferimento WeakSet, l'elemento associato viene rimosso anche dal WeakSet.

Verifica le tue conoscenze

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