Set
Toolbox

const tags = new Set();

tags.add("js");
tags.add("node").add("ts");     // add gives the set back, so you can chain
tags.add("js");                 // already there: quietly ignored

console.log(tags.size);         // 3, not 4
console.log(tags.has("node"), tags.has("go"));
console.log(tags);

const visits = ["home", "cart", "home", "pay", "cart", "home"];

const unique = [...new Set(visits)];     // the one line dedupe
console.log(unique);
console.log(new Set(visits).size, "different pages");

// works for letters too
console.log([...new Set("mississippi")].join(""));

// objects are compared by identity, not by what is inside
const a = { id: 1 };
console.log(new Set([a, a, { id: 1 }]).size);

const online = new Set(["asha", "ravi", "meera"]);

console.log(online.delete("ravi"));   // true: found and removed
console.log(online.delete("zoya"));   // false: was not there
console.log(online);

online.clear();                       // remove everything
console.log(online.size);

const colours = new Set(["red", "amber", "violet"]);

for (const colour of colours) {       // in the order they were added
  console.log(colour);
}

// forEach gives the value twice, to match the Map shape
colours.forEach((value, sameValue) => console.log(value === sameValue));

console.log([...colours].map((c) => c.toUpperCase()));  // spread for array tools

const frontend = new Set(["asha", "ravi", "meera"]);
const backend = new Set(["meera", "kiran", "asha"]);

console.log(frontend.union(backend));               // in either team
console.log(frontend.intersection(backend));        // in both teams
console.log(frontend.difference(backend));          // frontend only
console.log(frontend.symmetricDifference(backend)); // in exactly one team

const leads = new Set(["asha"]);
console.log(leads.isSubsetOf(frontend), frontend.isSupersetOf(leads));
console.log(leads.isDisjointFrom(new Set(["kiran"])));

// the same answers on older engines, using filter
const a = new Set([1, 2, 3, 4]);
const b = new Set([3, 4, 5]);

const union = new Set([...a, ...b]);
const both = new Set([...a].filter((x) => b.has(x)));
const onlyA = new Set([...a].filter((x) => !b.has(x)));

console.log(union, both, onlyA);

// a WeakSet marks objects without keeping them alive
const processed = new WeakSet();

function handle(order) {
  if (processed.has(order)) return `order ${order.id} already done`;
  processed.add(order);
  return `processing order ${order.id}`;
}

const order = { id: 42 };
console.log(handle(order));
console.log(handle(order));          // the same object is recognised

try { processed.add("42"); } catch (err) { console.log(err.constructor.name); }
console.log(typeof processed.size);  // no size and no looping

// who can do what: combine role permissions, then check what an action needs
const roles = {
  viewer: new Set(["read"]),
  editor: new Set(["read", "write"]),
  billing: new Set(["read", "invoice"]),
};

const permsFor = (...names) => names.reduce((all, n) => all.union(roles[n]), new Set());

const shree = permsFor("editor", "billing");
console.log([...shree]);

const can = (perms, ...needs) => new Set(needs).isSubsetOf(perms);
console.log(can(shree, "write", "invoice"));
console.log(can(permsFor("viewer"), "write"));

const missing = new Set(["read", "delete"]).difference(shree);
console.log("missing:", [...missing].join(", "));