Maps are key-value pairs which, unlike JS objects, allow objects to be used as keys.
In a plain Map, both objects and primitives can be used as keys. In a WeakMap, only objects can be used as keys.
The benefit that this gives us is that keys in WeakMaps can be garbage collected, and so we avoid potential memory leaks. The tradeoff here is that they are not enumerable, and you cannot see they keys or size of the map.
The following answer is taken from this SO thread:
Maybe the next explanation will be more clear for someone.
var k1 = {a: 1};
var k2 = {b: 2};
var map = new Map();
var wm = new WeakMap();
map.set(k1, 'k1');
wm.set(k2, 'k2');
k1 = null;
map.forEach(function (val, key) {
console.log(key, val); // k1 {a: 1}
});
k2 = null;
wm.get(k2); // undefined
As you see, after removing k1 key from the memory we can still access it inside the map. At the same time removing k2 key of WeakMap removes it from wm as well by reference.
That's why WeakMap hasn't enumerable methods like forEach, because there is no such thing as list of WeakMap keys, they are just references to another objects.
The difference between these two is near identical to that of Map and WeakMap above. WeakSets may only have objects stored within them and cannot be enumerated, but they have the added benefit that the objects within them can be garbage collected.
Typed arrays are not actually in-built javascript arrays, but ways of working with binary data from external sources. Let’s say you receive N bytes of data from somewhere; you can then “frame” that data with a view using types such as Int8 or Uint32 and an offset which basically says “treat this section of the data as a series of values of this type”.
Once that is done, you can perform array-like operations on that data such as viewing and modifying values.