Raccolte con chiave

Puoi utilizzare i valori letterali oggetto per archiviare coppie chiave-valore e gli array per archiviare raccolte di valori iterabili. ES6 introduce inoltre strutture di dati specializzate per soddisfare casi d'uso più granulari: Mappa per coppie chiave-valore e Imposta per valori individuali.

Mappa

Una mappa è una struttura di dati iterabile che archivia le informazioni come coppie chiave-valore, simili a un valore letterale oggetto. A differenza dei valori letterali oggetto, una mappa consente a valori e chiavi di avere qualsiasi tipo di dati e l'ordine in cui gli elementi vengono aggiunti a una mappa viene conservato 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 un array (o a qualsiasi oggetto iteratore) contenente oggetti simili a array composti da due elementi. Il primo elemento in ognuna di queste strutture di dati di due elementi diventa la chiave, mentre il secondo diventa il valore associato alla chiave. La forma più semplice è, di fatto, un array in cui ogni elemento è a sua volta un array composto da due elementi, la chiave e il 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 si differenzia da un valore letterale oggetto per il fatto che sia i valori sia 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 elementi della mappa, utilizza i metodi ereditati dal costruttore 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)

Le chiavi in una mappa sono univoche, il che significa che l'impostazione di una chiave identica sovrascrive la coppia chiave-valore memorizzata in precedenza:

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 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 mappa WeakMap contiene references "deboli", che devono essere riferimenti a oggetti o simboli che non sono stati aggiunti al registro globale dei simboli.

Per creare una mappa WeakMap, usa il costruttore WeakMap():

const myWeakMap = new WeakMap();

myWeakMap;
> WeakMap(0)

La sintassi di WeakMap è simile a quella di Map, ma WeakMaps non è iterabile e il tentativo di utilizzare qualsiasi valore diverso da un oggetto o un simbolo come chiave provoca un errore di sintassi. Quando non esistono references a una chiave fuori da WeakMap, l'oggetto o il simbolo e il valore associato nella mappa WeakMap sono entrambi idonei per la garbage collection.

Ciò consente casi d'uso come l'archiviazione dei metadati associati a un oggetto in una mappa WeakMap, utilizzando il riferimento all'oggetto come chiave. Se non esistono altri riferimenti a questo oggetto e quest'ultimo viene rimosso dalla memoria, vengono rimossi anche i metadati associati.

Configura

Un insieme è una raccolta iterabile di valori univoci in qualche modo simile a un array, anche se può contenere solo valori univoci. Come per una mappa, l'iterazione su un set mantiene l'ordine in cui gli elementi sono stati aggiunti.

Per creare un set, usa 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 array contenente più istanze dello stesso valore, viene conservata 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 set, utilizza i metodi ereditati dal costruttore Set. Questi metodi agiscono su un elemento in base al valore dell'elemento stesso, 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 []

Anche se gli insiemi non sono raccolte indicizzate e non sono destinati a essere utilizzati come ta, gli elementi in un insieme vengono ripetuti in ordine di inserzione. I tentativi di aggiungere un valore di elemento duplicato a un insieme vengono ignorati, 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 set, utilizza il metodo Array.from() o la sintassi distribuita:

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 set che contiene solo valori garbage-collectable, ad esempio riferimenti agli oggetti o simboli che non sono stati aggiunti al registro globale dei simboli.

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

const myWeakSet = new WeakSet();

myWeakSet;
> WeakSet []

La sintassi WeakSet è simile a Set, anche se un WeakSet non è iterabile e il tentativo di aggiungere qualsiasi valore diverso da un oggetto o un simbolo provoca un errore di sintassi. Come con WeakMap, quando non esistono altri references a un valore a cui fa riferimento un WeakSet, questo valore diventa idoneo per la garbage collection.

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

Verifica le tue conoscenze

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