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
Considerato quanto segue:
const myMap = new Map([ [ "myKey", "My string" ] ]); myMap.set( "myKey", 100 );
Che cosa restituisce myMap
?
100
"My string"
undefined