Map, Set, WeakMap, WeakSet

const map = new Map();

map.set('name', 'Алиса');
map.set(42, 'ответ');
map.set({ id: 1 }, 'объект-ключ');

map.get('name');   // 'Алиса'
map.get(42);       // 'ответ'
map.has('name');   // true
map.size;          // 3
map.delete(42);
map.clear();

const map = new Map([
    ['a', 1],
    ['b', 2],
]);

const map = new Map(Object.entries({ a: 1, b: 2 }));

for (const [key, value] of map) {
    console.log(key, value);
}

for (const key of map.keys()) {}
for (const value of map.values()) {}
for (const [key, value] of map.entries()) {}

map.forEach((value, key) => {});

Object.fromEntries(map);

function countWords(words) {
    const counts = new Map();

    for (const word of words) {
        counts.set(word, (counts.get(word) ?? 0) + 1);
    }

    return counts;
}

const set = new Set([1, 2, 2, 3]);
// Set(3) { 1, 2, 3 }

set.add(4);
set.has(2);   // true
set.size;     // 4
set.delete(2);
set.clear();

const unique = [...new Set([1, 2, 2, 3])]; // [1, 2, 3]

new Set([{ a: 1 }, { a: 1 }]).size; // 2

for (const value of set) {}
set.forEach((value) => {});

const a = new Set([1, 2, 3]);
const b = new Set([2, 3, 4]);

const intersection = new Set([...a].filter((x) => b.has(x))); // { 2, 3 }
const union = new Set([...a, ...b]);                         // { 1, 2, 3, 4 }
const difference = new Set([...a].filter((x) => !b.has(x))); // { 1 }

const wm = new WeakMap();

const key = {};
wm.set(key, 'value');
wm.get(key); // 'value'

const privates = new WeakMap();

class User {
    constructor(name) {
        privates.set(this, { name });
    }

    getName() {
        return privates.get(this).name;
    }
}

const cache = new WeakMap();

function process(obj) {
    if (cache.has(obj)) return cache.get(obj);
    const result = heavyComputation(obj);
    cache.set(obj, result);
    return result;
}

const ws = new WeakSet();
const obj = {};
ws.add(obj);
ws.has(obj); // true