Keyed collections

Maps

Map object

var sayings = new Map();
sayings.set('dog', 'woof');
sayings.set('cat', 'meow');
sayings.set('elephant', 'toot');
sayings.size; // 3
sayings.get('fox'); // undefined
sayings.has('bird'); // false
sayings.delete('dog');
sayings.has('dog'); // false

for (var [key, value] of sayings) {
  console.log(key + ' goes ' + value);
}
// "cat goes meow"
// "elephant goes toot"

sayings.clear();
sayings.size; // 0

Object and Map compared

• The keys of an Object are Strings, where they can be of any value for a Map.
• You can get the size of a Map easily while you have to manually keep track of size for an Object.
• The iteration of maps is in insertion order of the elements.
• An Object has a prototype, so there are default keys in the map. (this can be bypassed using map = Object.create(null)).

• Use maps over objects when keys are unknown until run time, and when all keys are the same type and all values are the same type.
• Use maps in case if there is a need to store primitive values as keys because object treats each key as a string whether it's a number value, boolean value or any other primitive value.
• Use objects when there is logic that operates on individual elements.

WeakMap object

const privates = new WeakMap();

function Public() {
  const me = {
    // Private data goes here
  };
  privates.set(this, me);
}

Public.prototype.method = function() {
  const me = privates.get(this);
  // Do stuff with private data in `me`...
};

module.exports = Public;

Sets

Set object

var mySet = new Set();
mySet.add(1);
mySet.add('some text');
mySet.add('foo');

mySet.has(1); // true
mySet.delete('foo');
mySet.size; // 2

for (let item of mySet) console.log(item);
// 1
// "some text"

Converting between Array and Set

Array.from(mySet);
[...mySet2];

mySet2 = new Set([1, 2, 3, 4]);

Array and Set compared

• Checking whether an element exists in a collection using indexOf for arrays is slow.
• Set objects let you delete elements by their value. With an array you would have to splice based on an element's index.
• The value NaN cannot be found with indexOf in an array.
• Set objects store unique values; you don't have to keep track of duplicates by yourself.

WeakSet object

• In contrast to Sets, WeakSets are collections of objects only and not of arbitrary values of any type.
• The WeakSet is weak: References to objects in the collection are held weakly. If there is no other reference to an object stored in the WeakSet, they can be garbage collected. That also means that there is no list of current objects stored in the collection. WeakSets are not enumerable.

Key and value equality of Map and Set

• Equality works like the identity comparison operator ===.
• -0 and +0 are considered equal.
• NaN is considered equal to itself (contrary to ===).