JavaScript Map・Set｜使い方とObject・配列との違い一覧

Mapは「どんな値でもキーにできる、順番つきのキーと値の組の集まり」、Setは「重複しない値の集まり」です。 どちらもES2015から使える組み込みオブジェクトで、Mapは辞書・キャッシュ・集計に、Setは重複除去・存在確認・集合演算に向いています。2024年からはSetに union（和集合）や intersection（共通部分）などの集合演算メソッドが加わり、Mapには Map.groupBy でグループ分けする方法も加わりました。

この記事では、MapとSetの全メソッドの早見表、Setの新メソッド7つとMap.groupBy・WeakMap、Object・配列との使い分け表を用意し、すべてのコードをNode.js 22（v22.22.2）で実行した出力を載せています。新メソッドがNode 22とChromium 141で使えるかを実際に確かめた対応表、ObjectとMap・配列とSetの追加・検索速度の実測、重複除去・出現回数カウント・LRUキャッシュ・配列の差分といったコピペできるレシピ、「オブジェクトをキーにすると見つからない」「JSON.stringifyで {} になる」といったつまずきの直し方まで扱います。オブジェクトや配列そのものの操作は、別記事「JavaScriptオブジェクト操作まとめ」「JavaScript 配列 操作 一覧」で扱っているため、ここではMapとSetに絞ります。

Map・Setのメソッド早見表

Mapの使い方（作成・追加・取得・削除・ループ）

Mapは set で入れて get で取り出し、件数は size で数えます。 Objectと違い、数値や真偽値、オブジェクトもそのままの型でキーになります。

// basic_map.mjs  （node basic_map.mjs で実行）
const stock = new Map();
stock.set("pen", 10).set("note", 3);   // set はMap自身を返すのでつなげられる
stock.set(1, "数値キー");
stock.set(true, "真偽値キー");
console.log(stock.get("pen"));      // 10
console.log(stock.get("eraser"));   // undefined
console.log(stock.has("note"));     // true
console.log(stock.size);            // 4
console.log(stock.delete("note"));  // true
console.log(stock.delete("note"));  // false（もうない）
console.log([...stock.keys()]);
console.log([...stock.values()]);
console.log([...stock.entries()]);
stock.forEach((value, key) => console.log(key, "=>", value));
for (const [key, value] of stock) console.log(`${key}: ${value}`);

const fromArr = new Map([["a", 1], ["b", 2]]);
const fromObj = new Map(Object.entries({ x: 10, y: 20 }));
console.log(fromArr, fromObj);
console.log(Object.fromEntries(fromObj));
stock.clear();
console.log(stock.size);

実行結果（Node.js v22.22.2）：

10
undefined
true
4
true
false
[ 'pen', 1, true ]
[ 10, '数値キー', '真偽値キー' ]
[ [ 'pen', 10 ], [ 1, '数値キー' ], [ true, '真偽値キー' ] ]
pen => 10
1 => 数値キー
true => 真偽値キー
pen: 10
1: 数値キー
true: 真偽値キー
Map(2) { 'a' => 1, 'b' => 2 } Map(2) { 'x' => 10, 'y' => 20 }
{ x: 10, y: 20 }
0

ポイントは3つです。

• keys()・values()・entries() は配列ではなくイテレーター（順に1つずつ取り出せるもの）を返します。配列のメソッドを使いたいときは [...map.keys()] のように展開します。
• forEach のコールバックは (値, キー) の順です。for...of の分割代入 [key, value] とは逆なので注意します。
• 順番は追加した順で固定です。既にあるキーを set し直しても位置は変わりません。

Setの使い方（追加・存在確認・削除）

Setは同じ値を1つしか持たない集まりで、add で入れて has で調べます。 重複は自動で無視されます。

// basic_set.mjs
const tags = new Set(["js", "css"]);
tags.add("html").add("js");      // 重複は無視される
console.log(tags);
console.log(tags.size);
console.log(tags.has("css"));
console.log(tags.delete("css"));
console.log([...tags]);
console.log([...tags.keys()], [...tags.values()]);
console.log([...tags.entries()]);
tags.forEach((value, sameValue, set) => console.log(value, sameValue, set === tags));
const nums = new Set([1, "1", NaN, NaN, 0, -0]);
console.log(nums);
tags.clear();
console.log(tags.size);

実行結果（Node.js v22.22.2）：

Set(3) { 'js', 'css', 'html' }
3
true
true
[ 'js', 'html' ]
[ 'js', 'html' ] [ 'js', 'html' ]
[ [ 'js', 'js' ], [ 'html', 'html' ] ]
js js true
html html true
Set(4) { 1, '1', NaN, 0 }
0

同じ値かどうかは「SameValueZero」という規則で判定されます。 1 と "1" は型が違うので別、NaN 同士は同じ、0 と -0 は同じです。=== との違いは NaN を同じとみなす点だけです。Setの keys() と values() が同じ結果になり、entries() が [値, 値] になるのは、Mapと同じ形で扱えるようにするためです。

Setの新メソッド（union・intersection・differenceなど）

ES2025で、Setに集合演算のメソッドが7つ加わりました。 Node.js 22とChromium 141では、追加の設定なしで使えることを確認しました。どれも元のSetは変えずに新しいSet（または真偽値）を返します。

// setops.mjs
const a = new Set(["pen", "note", "ruler"]);
const b = new Set(["note", "ruler", "tape"]);
console.log("union               ", a.union(b));
console.log("intersection        ", a.intersection(b));
console.log("difference          ", a.difference(b));
console.log("symmetricDifference ", a.symmetricDifference(b));
const small = new Set(["pen"]);
console.log("isSubsetOf          ", small.isSubsetOf(a));
console.log("isSupersetOf        ", a.isSupersetOf(small));
console.log("isDisjointFrom      ", small.isDisjointFrom(b));
console.log("元のaは変わらない   ", a);
// 引数はSetのような値（size・has・keys を持つ）。Mapも渡せる
const m = new Map([["pen", 1], ["tape", 2]]);
console.log("Mapと共通部分       ", a.intersection(m));
try { a.union(["tape"]); } catch (e) { console.log(e.constructor.name + ": " + e.message); }
console.log("配列はSetに包む     ", a.union(new Set(["tape"])));

実行結果（Node.js v22.22.2）：

union                Set(4) { 'pen', 'note', 'ruler', 'tape' }
intersection         Set(2) { 'note', 'ruler' }
difference           Set(1) { 'pen' }
symmetricDifference  Set(2) { 'pen', 'tape' }
isSubsetOf           true
isSupersetOf         true
isDisjointFrom       true
元のaは変わらない    Set(3) { 'pen', 'note', 'ruler' }
Mapと共通部分        Set(1) { 'pen' }
TypeError: The .size property is NaN
配列はSetに包む      Set(4) { 'pen', 'note', 'ruler', 'tape' }

引数に配列をそのまま渡すと TypeError: The .size property is NaN になります。 引数は「size・has・keys を持つSetのような値」と決められているためです。配列は new Set(arr) で包んでから渡します。逆に、Mapは条件を満たすのでそのまま渡せます（キーが比べられます）。

新メソッドの対応状況（実測）

確認に使ったコードは次のとおりです（Node側）。

// support.mjs
console.log(process.version);
const names = ["union","intersection","difference","symmetricDifference","isSubsetOf","isSupersetOf","isDisjointFrom"];
for (const n of names) console.log("Set.prototype."+n, typeof Set.prototype[n]);
console.log("Map.groupBy", typeof Map.groupBy, "Object.groupBy", typeof Object.groupBy);
console.log("Map.prototype.getOrInsert", typeof Map.prototype.getOrInsert, "getOrInsertComputed", typeof Map.prototype.getOrInsertComputed);
console.log("Iterator.prototype.map", typeof Iterator?.prototype?.map, "Iterator.prototype.toArray", typeof Iterator?.prototype?.toArray);

v22.22.2
Set.prototype.union function
Set.prototype.intersection function
Set.prototype.difference function
Set.prototype.symmetricDifference function
Set.prototype.isSubsetOf function
Set.prototype.isSupersetOf function
Set.prototype.isDisjointFrom function
Map.groupBy function Object.groupBy function
Map.prototype.getOrInsert undefined getOrInsertComputed undefined
Iterator.prototype.map function Iterator.prototype.toArray function

getOrInsert が使えない環境では、has・get・set の3行で同じことが書けます（後半の「グループ化」レシピを参照）。

Map.groupByでグループ分けする

Map.groupBy(配列, 関数) は、関数が返した値をキーにして要素をまとめたMapを返します。 Object.groupBy との違いは、キーに文字列以外（オブジェクトや数値）をそのまま使える点です。

// groupby.mjs
const orders = [
  { id: 1, item: "pen", status: "shipped" },
  { id: 2, item: "note", status: "pending" },
  { id: 3, item: "tape", status: "shipped" },
];
const byStatus = Map.groupBy(orders, (o) => o.status);
console.log(byStatus);
console.log(byStatus.get("shipped").map((o) => o.id));
// キーにオブジェクトを使えるのがObject.groupByとの違い
const vip = { name: "VIP" }, normal = { name: "通常" };
const members = [{ n: "A", p: 1200 }, { n: "B", p: 300 }, { n: "C", p: 5000 }];
const byRank = Map.groupBy(members, (m) => (m.p >= 1000 ? vip : normal));
console.log(byRank.get(vip).map((m) => m.n), byRank.get(normal).map((m) => m.n));
console.log(Object.groupBy(orders, (o) => o.status));

実行結果（Node.js v22.22.2）：

Map(2) {
  'shipped' => [
    { id: 1, item: 'pen', status: 'shipped' },
    { id: 3, item: 'tape', status: 'shipped' }
  ],
  'pending' => [ { id: 2, item: 'note', status: 'pending' } ]
}
[ 1, 3 ]
[ 'A', 'C' ] [ 'B' ]
[Object: null prototype] {
  shipped: [
    { id: 1, item: 'pen', status: 'shipped' },
    { id: 3, item: 'tape', status: 'shipped' }
  ],
  pending: [ { id: 2, item: 'note', status: 'pending' } ]
}

ObjectとMapの違い・使い分け

「決まった項目を持つデータ（レコード）」はObject、「あとから増減するキーと値の辞書」はMap、と考えると迷いません。

プロトタイプ汚染との関係

Objectは Object.prototype を継承しているため、外部から来た文字列をキーにすると思わぬ動きをすることがあります。 次の例は、単語の出現回数をObjectで数えたときと、外部JSONのキーをそのままコピーしたときの動きです。

// proto.mjs
const counts = {};
for (const w of ["toString", "constructor"]) counts[w] = (counts[w] || 0) + 1;
console.log(counts);
const input = JSON.parse('{"__proto__": {"isAdmin": true}}');
const target = {};
for (const [k, v] of Object.entries(input)) target[k] = v;  // 単純コピー
console.log(target.isAdmin, ({}).isAdmin);
const mapCounts = new Map();
for (const w of ["toString", "constructor"]) mapCounts.set(w, (mapCounts.get(w) ?? 0) + 1);
console.log(mapCounts);
const safe = new Map(Object.entries(input));
console.log(safe.get("__proto__"), safe.get("isAdmin"));
console.log("toString" in {}, new Map().has("toString"));

実行結果（Node.js v22.22.2）：

{
  toString: 'function toString() { [native code] }1',
  constructor: 'function Object() { [native code] }1'
}
true undefined
Map(2) { 'toString' => 1, 'constructor' => 1 }
{ isAdmin: true } undefined
true false

Objectで数えると、継承した関数に 1 が文字列連結されてしまいます。 また target["__proto__"] = … はプロパティの追加ではなくプロトタイプの差し替えになり、target.isAdmin が true になりました（この例では target だけが影響を受け、{} 全体には広がっていません）。Mapにすると、どちらも普通のキーとして扱われ、意図どおりに動きます。 Objectを辞書として使い続けたい場合は Object.create(null) でプロトタイプのないオブジェクトを作る方法もあります。

配列とSetの違い・使い分け

順番や重複に意味があるなら配列、「入っているかどうか」だけが大事ならSetです。

速さを実測：Object vs Map、配列 vs Set

判断の材料として、Node.js 22で追加・検索・削除の時間を測りました。 2コアのコンテナで、同じ処理を5回測った中央値です。環境で数値は揺れるため、2回実行した結果を両方載せます。

// bench.mjs  （node bench.mjs）
const N = 1_000_000;
const keys = Array.from({ length: N }, (_, i) => "key" + i);
const median = (a) => a.sort((x, y) => x - y)[Math.floor(a.length / 2)];
function measure(fn) {
  const t = [];
  for (let r = 0; r < 5; r++) { const s = performance.now(); fn(); t.push(performance.now() - s); }
  return median(t).toFixed(1) + " ms";
}
let sink = 0;
console.log(`文字列キー ${N.toLocaleString()} 件`);
console.log("追加  Object      ", measure(() => { const o = {}; for (const k of keys) o[k] = 1; sink += o.key0; }));
console.log("追加  Map         ", measure(() => { const m = new Map(); for (const k of keys) m.set(k, 1); sink += m.size; }));
const o = {}; for (const k of keys) o[k] = 1;
const m = new Map(); for (const k of keys) m.set(k, 1);
console.log("検索  Object(in)  ", measure(() => { let c = 0; for (const k of keys) if (k in o) c++; sink += c; }));
console.log("検索  Map.has     ", measure(() => { let c = 0; for (const k of keys) if (m.has(k)) c++; sink += c; }));
console.log("削除  delete obj  ", measure(() => { const x = {}; for (let i = 0; i < 100_000; i++) x[keys[i]] = 1; for (let i = 0; i < 100_000; i++) delete x[keys[i]]; }), "(10万件)");
console.log("削除  Map.delete  ", measure(() => { const x = new Map(); for (let i = 0; i < 100_000; i++) x.set(keys[i], 1); for (let i = 0; i < 100_000; i++) x.delete(keys[i]); }), "(10万件)");
const arr = keys.slice(0, 10_000);
const set = new Set(arr);
const q = keys.slice(5_000, 15_000);
console.log("存在確認 Array.includes", measure(() => { let c = 0; for (const k of q) if (arr.includes(k)) c++; sink += c; }), "(1万件×1万回)");
console.log("存在確認 Set.has       ", measure(() => { let c = 0; for (const k of q) if (set.has(k)) c++; sink += c; }), "(1万件×1万回)");
const rec = { id: 1, name: "pen", price: 120 };
const recMap = new Map(Object.entries(rec));
console.log("固定キー読み取り Object", measure(() => { let s = 0; for (let i = 0; i < 10_000_000; i++) s += rec.price; sink += s; }), "(1000万回)");
console.log("固定キー読み取り Map   ", measure(() => { let s = 0; for (let i = 0; i < 10_000_000; i++) s += recMap.get("price"); sink += s; }), "(1000万回)");

読み取り方は次のとおりです。

• 配列の includes をSetの has に変えると、この条件では100倍以上速くなりました。 配列は先頭から順に探すため、件数×回数で時間が増えます。何度も「入っているか」を調べるなら、最初に一度Setを作るのが効果的です。
• ObjectとMapの差は、この計測では数倍以内で、処理によって逆転します。 文字列キーの検索や決まったキーの読み取りはObjectが速く、追加と削除をくり返す処理はMapが速い結果でした。
• ObjectとMapは速さより「用途」で選ぶのがおすすめです。 表の差が問題になるのは数十万件以上を何度も回す場合で、多くの処理ではキーの型・順番・JSON化のしやすさのほうが効いてきます。

コピペで使えるレシピ集

よく使う5つの処理を、そのまま動く形でまとめました。

// recipes.mjs
// 1. 重複除去
const ids = [3, 1, 3, 2, 1];
console.log([...new Set(ids)]);
// オブジェクト配列をidで重複除去（後から来たもので上書き）
const rows = [{ id: 1, v: "a" }, { id: 2, v: "b" }, { id: 1, v: "c" }];
console.log([...new Map(rows.map((r) => [r.id, r])).values()]);

// 2. 出現回数カウント（上位2件）
const words = ["pen", "note", "pen", "tape", "pen", "note"];
const freq = new Map();
for (const w of words) freq.set(w, (freq.get(w) ?? 0) + 1);
console.log(freq);
console.log([...freq].sort((a, b) => b[1] - a[1]).slice(0, 2));

// 3. グループ化（Map.groupByを使わない書き方。getOrInsertの代わりにもなる）
const tasks = [{ t: "設計", who: "佐藤" }, { t: "実装", who: "鈴木" }, { t: "レビュー", who: "佐藤" }];
const byWho = new Map();
for (const task of tasks) {
  if (!byWho.has(task.who)) byWho.set(task.who, []);
  byWho.get(task.who).push(task.t);
}
console.log(byWho);

// 4. キャッシュ（メモ化）
const cache = new Map();
let calls = 0;
function slowSquare(n) {
  if (cache.has(n)) return cache.get(n);
  calls++;
  const r = n * n;
  cache.set(n, r);
  return r;
}
slowSquare(4); slowSquare(4); slowSquare(5);
console.log({ calls, size: cache.size });

// 4'. サイズ上限つきキャッシュ（LRU）: Mapが追加順を保つことを利用
class LRU {
  constructor(max) { this.max = max; this.map = new Map(); }
  get(k) {
    if (!this.map.has(k)) return undefined;
    const v = this.map.get(k);
    this.map.delete(k); this.map.set(k, v);   // 末尾へ移動
    return v;
  }
  set(k, v) {
    this.map.delete(k); this.map.set(k, v);
    if (this.map.size > this.max) this.map.delete(this.map.keys().next().value); // 先頭=最も古い
  }
}
const lru = new LRU(2);
lru.set("a", 1); lru.set("b", 2); lru.get("a"); lru.set("c", 3);
console.log([...lru.map.keys()]);

// 5. 配列の差分（追加・削除・共通）
const before = ["pen", "note", "ruler"];
const after = ["note", "ruler", "tape"];
const B = new Set(before), A = new Set(after);
console.log({ added: [...A.difference(B)], removed: [...B.difference(A)], kept: [...A.intersection(B)] });
// Set新メソッドがない環境（Node 20など）での書き方
console.log({ added: after.filter((x) => !B.has(x)), removed: before.filter((x) => !A.has(x)) });

// おまけ: Mapの並べ替え・絞り込み・変換
const price = new Map([["pen", 120], ["note", 300], ["tape", 80]]);
console.log(new Map([...price].sort((a, b) => a[1] - b[1])));
console.log(new Map(price.entries().filter(([, p]) => p >= 100)));   // イテレーターヘルパー
console.log(price.keys().map((k) => k.toUpperCase()).toArray());

実行結果（Node.js v22.22.2）：

[ 3, 1, 2 ]
[ { id: 1, v: 'c' }, { id: 2, v: 'b' } ]
Map(3) { 'pen' => 3, 'note' => 2, 'tape' => 1 }
[ [ 'pen', 3 ], [ 'note', 2 ] ]
Map(2) { '佐藤' => [ '設計', 'レビュー' ], '鈴木' => [ '実装' ] }
{ calls: 2, size: 2 }
[ 'a', 'c' ]
{ added: [ 'tape' ], removed: [ 'pen' ], kept: [ 'note', 'ruler' ] }
{ added: [ 'tape' ], removed: [ 'pen' ] }
Map(3) { 'tape' => 80, 'pen' => 120, 'note' => 300 }
Map(2) { 'pen' => 120, 'note' => 300 }
[ 'PEN', 'NOTE', 'TAPE' ]

レシピごとの要点です。

WeakMap・WeakSetの使い方

WeakMapは「キーのオブジェクトがほかで使われなくなったら、組ごと自動で消える」Mapです。 オブジェクト本体を書き換えずに、外付けのデータ（閲覧回数、計算結果のキャッシュ、DOM要素ごとの状態など）を結びつけるのに向いています。

// weak.mjs
const meta = new WeakMap();
let item = { name: "pen" };
meta.set(item, { viewed: 3 });
console.log(meta.get(item), meta.has(item));
try { meta.set("pen", 1); } catch (e) { console.log(e.constructor.name + ": " + e.message); }
console.log(meta.size, typeof meta.keys, typeof meta.forEach);
const ws = new WeakSet();
ws.add(item);
console.log(ws.has(item));
try { ws.add(1); } catch (e) { console.log(e.constructor.name + ": " + e.message); }
const sym = Symbol("k");
meta.set(sym, "symbol key");
console.log(meta.get(sym));
try { meta.set(Symbol.for("reg"), 1); } catch (e) { console.log(e.constructor.name + ": " + e.message); }

実行結果（Node.js v22.22.2）：

{ viewed: 3 } true
TypeError: Invalid value used as weak map key
undefined undefined undefined
true
TypeError: Invalid value used in weak set
symbol key
TypeError: Invalid value used as weak map key

文字列や数値をキーにすると TypeError: Invalid value used as weak map key になります。 Symbol.for() で登録したSymbolもキーにできません（どこからでも取り出せるため、消える時期が決まらない）。

メモリが本当に解放されるかを実測

20万個のオブジェクトをキーにして登録し、キーへの参照を手放してからGC（ガベージコレクション＝不要なメモリの回収）を実行しました。

// gc.mjs  （node --expose-gc gc.mjs で実行）
const mem = () => (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(1) + " MB";
function run(Kind) {
  global.gc();
  const store = new Kind();
  let keys = [];
  for (let i = 0; i < 200_000; i++) { const k = { i }; keys.push(k); store.set(k, new Array(20).fill(i)); }
  const filled = mem();
  keys = null;                // キーへの参照を手放す
  global.gc();
  return `${Kind.name}: 登録直後 ${filled} → キーを手放してGC後 ${mem()}` + (store.size !== undefined ? ` (size=${store.size})` : "");
}
console.log(run(Map));
console.log(run(WeakMap));

Map: 登録直後 63.7 MB → キーを手放してGC後 56.3 MB (size=200000)
WeakMap: 登録直後 65.6 MB → キーを手放してGC後 11.7 MB

Mapはキーを持ち続けるので20万件が残り、WeakMapは組ごと回収されました。 「オブジェクトに付けたデータを、オブジェクトと一緒に片づけたい」場面ではWeakMapを選ぶと、delete の書き忘れを気にせずに済みます。

よくあるつまずきと直し方

MapとSetで迷いやすい点を、実行結果つきでまとめます。

// pitfalls.mjs
// 1) オブジェクト・配列のキーは「参照」で比較
const m = new Map();
m.set({ id: 1 }, "A");
console.log(m.get({ id: 1 }));          // 別のオブジェクトなので見つからない
const key = { id: 1 };
m.set(key, "B");
console.log(m.get(key));
m.set([1, 2], "arr");
console.log(m.has([1, 2]));
// 直し方: プリミティブのキーにする
const m2 = new Map();
const k = (p) => `${p.x},${p.y}`;
m2.set(k({ x: 1, y: 2 }), "点A");
console.log(m2.get(k({ x: 1, y: 2 })));
// 2) Setも参照で比較
const s = new Set([{ id: 1 }, { id: 1 }]);
console.log(s.size);
// 3) JSON.stringify は {} になる
const map = new Map([["pen", 10]]);
const set = new Set(["js", "css"]);
console.log(JSON.stringify(map), JSON.stringify(set));
console.log(JSON.stringify({ map, set }));
// 直し方: 配列/オブジェクトへ変換して保存、読み込み時に戻す
const json = JSON.stringify({ map: [...map], set: [...set] });
console.log(json);
const parsed = JSON.parse(json);
console.log(new Map(parsed.map), new Set(parsed.set));
console.log(JSON.stringify(Object.fromEntries(map)));
// replacer でまとめて変換
const replacer = (_k, v) => v instanceof Map ? Object.fromEntries(v) : v instanceof Set ? [...v] : v;
console.log(JSON.stringify({ map, set }, replacer));
// 4) ブラケットで代入してもMapの中身にはならない
const wrong = new Map();
wrong["pen"] = 10;
console.log(wrong.get("pen"), wrong.size, wrong.pen);
// 5) NaN をキーにできる、0と-0は同じ
const z = new Map([[NaN, "nan"], [0, "zero"]]);
console.log(z.get(NaN), z.get(-0));
// 6) ループ中に追加した値もそのループで回る
const loop = new Set([1]);
let count = 0;
for (const v of loop) { if (v < 3) loop.add(v + 1); count++; }
console.log([...loop], count);
// 7) structuredClone はMap/Setを複製できる
const c = structuredClone(map);
console.log(c, c !== map);

実行結果（Node.js v22.22.2）：

undefined
B
false
点A
2
{} {}
{"map":{},"set":{}}
{"map":[["pen",10]],"set":["js","css"]}
Map(1) { 'pen' => 10 } Set(2) { 'js', 'css' }
{"pen":10}
{"map":{"pen":10},"set":["js","css"]}
undefined 0 10
nan zero
[ 1, 2, 3 ] 3
Map(1) { 'pen' => 10 } true

深いコピーが必要なら structuredClone(map) が使えます。 MapとSetは中身ごと複製されます（キーのオブジェクトも複製されるので、元のオブジェクトでは get できなくなる点に注意します）。

TypeScriptで型をつける

TypeScriptでは Map<キーの型, 値の型>・Set<値の型> と書きます。 空で作るときは型引数を書いておくと、あとで入れる値がチェックされます。

const stock = new Map<string, number>();
stock.set("pen", 10);
const qty = stock.get("pen");          // number | undefined
const safe = stock.get("pen") ?? 0;    // number
const tags = new Set<string>(["js"]);
const byStatus: Map<"shipped" | "pending", { id: number }[]> = new Map();

get の戻り値は常に「値の型 | undefined」になります。 has で確かめたあとでも undefined が外れないため、?? で既定値を入れるか、上のレシピのように get の結果を変数に受けてから確かめます。

よくある質問

Q. MapとObject、結局どちらを使えばよいですか？ A. 項目名が決まっているデータはObject、キーがあとから増減する辞書やキャッシュはMapがおすすめです。キーが文字列以外、追加順を保ちたい、件数を頻繁に数える、外部入力の文字列をキーにする、のいずれかに当てはまればMapを選びます。JSONでそのまま送りたいデータはObjectのほうが扱いやすいです。

Q. Setの union や intersection はいつから使えますか？ A. ES2025の機能で、Node.js 22以降と主要ブラウザの現行版で使えます。 この記事ではNode.js 22.22.2とChromium 141で動作を確認しました。Node 20を対象にする場合は、レシピの filter + has の書き方を使います。

Q. MapやSetの中身をlocalStorageに保存するには？ A. JSON.stringify([...map]) で配列にしてから保存し、読み込むときに new Map(JSON.parse(text)) で戻します。 そのまま JSON.stringify(map) すると {} になります。Setも [...set] と new Set(...) で同じように扱えます。

Q. WeakMapはどんなときに使いますか？ A. オブジェクトに付けたデータを、そのオブジェクトと一緒に自動で片づけたいときです。 たとえばDOM要素ごとの状態や、オブジェクトごとの計算結果のキャッシュです。中身を一覧したい・件数を知りたい場合は、通常のMapを使います。

まとめ

• Mapは何でもキーにできる順番つき辞書、Setは重複しない値の集まり。件数は size（プロパティ）
• Setの新メソッド7つ（union・intersection・difference など）はNode 22で使える。引数は配列ではなくSet
• グループ分けは Map.groupBy、キーにオブジェクトを使えるのが Object.groupBy との違い
• 決まった項目のデータはObject、増減する辞書・キャッシュ・外部入力のキーはMap
• 存在確認をくり返すなら配列よりSet。実測では includes から has で100倍以上速くなった
• オブジェクトのキーは参照で比較、JSON.stringify は {}。配列やプリミティブに変換して扱う
• オブジェクトに外付けするデータはWeakMap。キーを手放すと組ごと回収される

株式会社RJCでは、JavaScriptのMapとSetの使い分けを仲間と学び合っています。こうした知識を共有しながら、日々技術を磨いています。

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。