Map и Set

Set — это множество: набор значений, где каждое встречается ровно один раз. Добавить одно и то же дважды никто не запрещает, просто во второй раз ничего не произойдёт. Основные действия — add, has, delete и свойство size.

const tags = new Set(["js", "css", "js"]);
tags.add("js");
tags.add("html");
console.log(tags.size);
console.log(tags.has("css"));
console.log([...tags]);

Сравнение «уже есть?» строгое, как у ===, с одной поблажкой: NaN считается равным самому себе (в обычном сравнении это не так). Число 5 и строка "5" — разные значения. А два объекта с одинаковыми полями — тоже разные: Set смотрит не на содержимое, а на то, один ли это объект в памяти.

const s = new Set();
s.add(5);
s.add("5");
s.add(NaN);
s.add(NaN);
console.log(s.size);

Map — словарь пар «ключ → значение». От объекта его отличает главное: ключом может быть что угодно — число, булево, функция и, самое ценное, другой объект. Это позволяет привязывать данные к объекту, не трогая его самого.

const user = { name: "Аня" };
const visits = new Map();
visits.set(user, 3);
visits.set(2026, "год");
console.log(visits.get(user));
console.log(visits.get(2026));
console.log(visits.size);

Набор методов маленький и предсказуемый: set(ключ, значение) кладёт пару, get достаёт значение (или undefined, если пары нет), has отвечает да/нет, delete убирает пару, clear — все сразу. set возвращает саму карту, поэтому вызовы можно ставить цепочкой.

У обычного объекта ключи — всегда строки (или символы). Напишете obj[1] — единица молча станет "1", а obj[true] превратится в "true". Map ничего не преобразует и хранит ключ ровно таким, каким его дали.

const obj = {};
obj[1] = "число";
obj["1"] = "строка";
console.log(Object.keys(obj));
console.log(obj[1]);
const map = new Map();
map.set(1, "число").set("1", "строка");
console.log(map.size);

const obj = {};
console.log("toString" in obj);
const map = new Map();
console.log(map.has("toString"));

Третье отличие бытовое, но приятное: у Map размер лежит в свойстве size, а у объекта его приходится вычислять через Object.keys(obj).length — то есть каждый раз строить временный массив ключей.

Обе коллекции перебираются через for..of и хранят порядок вставки: что положили первым, то первым и придёт. Map на каждом шаге отдаёт пару-массив [ключ, значение] — её удобно сразу разложить деструктуризацией.

const price = new Map([["хлеб", 40], ["чай", 120]]);
for (const [item, cost] of price) {
  console.log(item, cost);
}
console.log([...price.keys()]);
console.log(price.size);

У Map есть три «среза»: keys(), values() и entries(). У Set те же методы существуют для совместимости, только keys() и values() там — одно и то же. Размер у обеих коллекций — свойство size, без скобок; забудете и напишете size() — получите ошибку.

const online = new Set(["ann", "bob"]);
online.delete("ann");
console.log(online.has("ann"));
console.log(online.size);
online.clear();
console.log(online.size);

Объект с числовыми ключами при переборе сортирует их по возрастанию, независимо от того, в каком порядке вы их добавляли. Map всегда сохраняет порядок вставки. Если порядок для вас важен — это ещё один довод в пользу Map.

Правило грубое, но рабочее: нужна проверка «есть ли такое значение» — берите Set; нужны пары с нестроковыми ключами или частые добавления и удаления — Map; всё остальное прекрасно живёт в массиве и объекте.

Переходы между структурами дешёвые: new Set(массив) убирает дубликаты, [...set] возвращает массив, new Map(Object.entries(obj)) делает карту из объекта, а Object.fromEntries(map) — объект из карты. Так что выбор не навсегда.

У обычной Map есть побочный эффект: пока карта жива, живы и все её ключи. Объект, который вы положили ключом, не будет удалён сборщиком мусора, даже если во всей программе на него больше никто не ссылается. WeakMap держит ключи «слабо» — не мешает объекту исчезнуть, и пара пропадает вместе с ним.

let key = { id: 1 };
const cache = new WeakMap();
cache.set(key, "результат");
console.log(cache.has(key));
key = null; // ссылок больше нет — пара исчезнет сама, когда дойдут руки у сборщика
console.log(cache.size);

Ограничения строгие: ключами могут быть только объекты (и символы), перебора и size нет — содержимое может измениться в любой момент, поэтому показывать его было бы нечестно. Из методов остаются get, set, has, delete. Есть и WeakSet — то же самое, но для значений. Новичку они нужны редко: типичные случаи — кеш результатов и служебные пометки к чужим объектам.