Puedes usar literales de objeto para almacenar pares clave-valor y arreglos para almacenar colecciones de valores iterables. ES6 también presenta estructuras de datos especializadas para adaptarse a casos de uso más detallados: asignación para pares clave-valor y configuración para valores individuales.
Map
Un mapa es una estructura de datos iterable que almacena información como pares clave-valor, similar a un literal de objeto. A diferencia de los literales de objeto, un mapa permite que los valores y las claves tengan cualquier tipo de datos, y los elementos de orden que se agregan a un mapa se conservan cuando se itera sobre él.
Para crear un mapa, usa el constructor Map():
const myMap = new Map();
myMap;
> Map(0)
Puedes prepropagar datos de un mapa mediante una sintaxis similar a un array (o a cualquier objeto iterador) que contenga objetos similares a un array compuestos por dos elementos. El primer elemento de cada una de estas estructuras de datos de dos elementos se convierte en la clave, mientras que el segundo se convierte en el valor asociado con esa clave. La forma más simple de esto es, en efecto, un array en el que cada elemento es un array compuesto por dos elementos: la clave y el valor del elemento que se agregará al mapa:
const myMap = new Map([
[ "myKey", "A string value" ],
[ "mySecondKey", 500 ],
[ "myThirdKey", true ]
]);
myMap;
> Map(3) {'myKey' => 'A string value', 'mySecondKey' => 500, 'myThirdKey' => true}
Una vez más, un objeto Map difiere de un literal de objeto en que tanto los valores y las claves pueden tomar cualquier tipo de datos y valor:
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'}
Para obtener, configurar o borrar elementos de Map, usa los métodos heredados del constructor 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)
Las claves de un mapa son únicas, lo que significa que, cuando se configura una clave idéntica, se reemplaza el par clave-valor almacenado con anterioridad:
const myMap = new Map([ [ "myKey", "A string value" ] ]);
myMap.set( "myKey", 500 );
myMap;
> Map(1) {'myKey' => 500}
Al igual que con los objetos, puedes asignar un mapa a una variable declarada con const y, luego, modificar ese mapa. Sin embargo, al igual que con otros casos de uso de const, no puedes modificar ni borrar la variable en sí:
const myMap = new Map();
myMap.set( "myKey", "A string value" );
myMap;
> Map(1) {'myKey' => 500}
WeakMap
Un WeakMap es un mapa que contiene references "débiles", que deben ser referencias a objetos o símbolos que no se hayan agregado al registro global de símbolos.
Para crear un WeakMap, usa el constructor WeakMap():
const myWeakMap = new WeakMap();
myWeakMap;
> WeakMap(0)
La sintaxis de WeakMap es similar a la de Map, pero WeakMaps no es iterable, y tratar de usar cualquier valor que no sea un objeto o un símbolo como clave provoca un error de sintaxis. Cuando no existen references a una clave fuera de WeakMap, ese objeto o símbolo, y el valor asociado en WeakMap, son aptos para la recolección de elementos no utilizados.
Esto permite casos de uso como el almacenamiento de metadatos asociados con un objeto en un WeakMap, con la referencia al objeto como la clave. Si no existen otras referencias a este objeto y el objeto se quita de la memoria, también se quitan los metadatos asociados.
Establecer
Un conjunto es una colección iterable de valores únicos similar a un array, aunque un conjunto solo puede contener valores únicos. Al igual que con un mapa, la iteración sobre un conjunto conserva los elementos de orden que se le agregaron.
Para crear un conjunto, usa el constructor Set():
const mySet = new Set();
mySet;
> Set []
También puedes crear un conjunto a partir de un literal de arreglo:
const mySet = new Set([ 1, 2, 3 ]);
mySet;
> Set(3) [ 1, 2, 3 ]
Debido a que un conjunto no permite elementos duplicados, cuando se crea un conjunto a partir de un array que contiene varias instancias del mismo valor, solo retiene la primera instancia de ese valor:
const mySet = new Set([ 1, 2, 3, 2 ]);
mySet;
> Set(3) [ 1, 2, 3 ]
Para agregar o quitar elementos de un conjunto, usa los métodos heredados del constructor Set. Estos métodos actúan sobre un elemento según el valor de este, en lugar de hacer referencia a un índice:
const mySet = new Set();
mySet.add( "My value." );
mySet;
> Set [ "My value." ]
mySet.has( "My value." );
> true
mySet.delete( "My value." );
mySet;
> Set []
Si bien los conjuntos no son colecciones indexadas y no están destinados a usarse como tales, los elementos de un conjunto se iteran en orden de inserción. Se omiten los intentos de agregar un valor de elemento duplicado a un conjunto, lo que conserva el orden de inserción original:
const mySet = new Set([ 1, 2, 3 ]);
mySet;
> Set(3) [ 1, 2, 3 ]
mySet.add( 2 );
> Set(3) [ 1, 2, 3 ]
Para crear un array a partir de un conjunto, usa el método Array.from() o la sintaxis de distribución:
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 es un conjunto que contiene solo valores recolectables de elementos no utilizados, como referencias a objetos o símbolos que no se agregaron al registro de símbolos global.
Para crear un WeakSet, usa el constructor WeakSet():
const myWeakSet = new WeakSet();
myWeakSet;
> WeakSet []
La sintaxis de WeakSet es similar a la de Set, aunque un WeakSet no es iterable. Además, intentar agregar cualquier valor que no sea un objeto o un símbolo genera un error de sintaxis. Al igual que con WeakMap, cuando no existen otras references a un valor al que hace referencia un WeakSet, ese valor se vuelve apto para la recolección de elementos no utilizados.
Esto permite casos de uso, como la agregación de una sola colección iterable de objetos relacionados. Si no existen otras referencias a un objeto al que hace referencia el WeakSet, el elemento asociado también se quita del WeakSet.
Verifica tus conocimientos
Por lo siguiente:
const myMap = new Map([ [ "myKey", "My string" ] ]);
myMap.set( "myKey", 100 );
¿Qué devuelve myMap?
100"My string"undefined