JavaScriptオブジェクト操作まとめ｜keys・entries・コピー方法一覧

JavaScriptのオブジェクト操作は、Object.keys・Object.entries・Object.fromEntries などの Object の静的メソッドと、スプレッド構文（...）、分割代入、structuredClone の組み合わせで書けます。 「配列に変換して加工し、fromEntries でオブジェクトに戻す」「浅いコピーはスプレッド、深いコピーは structuredClone」の2つを押さえると、ほとんどの処理がすっきり書けます。

この記事では、作成・追加・削除・存在確認・列挙・結合・コピー・比較・凍結・グループ化までを用途別の逆引き表にまとめ、すべてのコードをNode.js 22（v22.22.2）で実行した出力をコメントで載せています。さらに、Date・Map・Set・関数・循環参照・クラスなど14種類の値で structuredClone と JSON.parse(JSON.stringify()) の結果を実測した比較表、キーの列挙順のルール、Mapとの使い分け表、DataCloneError などよくあるエラーの直し方まで扱います。配列のメソッドは別記事「JavaScript 配列 操作 一覧」で扱っているため、ここではオブジェクトに絞ります。

オブジェクト操作の逆引き早見表

加工は「Object.entries で配列にする → 配列メソッドで加工 → Object.fromEntries で戻す」が基本の型です。

検証環境

以降のコードは Node.js v22.22.2 で、ESモジュール（.mjs、strict mode）として実行しました。 // → のコメントがそのまま出力です（表示を見やすくするため改行だけ詰めています）。Object.groupBy など新しいメソッドをブラウザで使うときは、対象ブラウザの対応状況をMDNで確認してください。

node --version   # → v22.22.2
node obj.mjs

オブジェクトを作る・追加する・削除する

const item = { id: 1, name: "ノート", price: 300 };
const key = "stock";
const item2 = { ...item, [key]: 5, ["tag_" + 1]: "文具" };
console.log(item2);
// → { id: 1, name: 'ノート', price: 300, stock: 5, tag_1: '文具' }

const name = "ペン", price = 120;
console.log({ name, price });       // → { name: 'ペン', price: 120 }（省略記法）

const task = { title: "買い物" };
task.done = false;
task["due-date"] = "2026-10-05";    // ハイフンを含むキーは [] で
console.log(task);
// → { title: '買い物', done: false, 'due-date': '2026-10-05' }
console.log(delete task.done, task);
// → true { title: '買い物', 'due-date': '2026-10-05' }

キー名を変数で決めたいときは [key]: 値（計算されたプロパティ名）を使います。 delete は元のオブジェクトを変更します。元を残したまま「あるキーを除いた新しいオブジェクト」が欲しいときは、残余プロパティ（...rest）が便利です。

const { done, ...rest } = { title: "a", done: true, memo: "b" };
console.log(rest); // → { title: 'a', memo: 'b' }

継承するプロパティが一切ない入れ物は Object.create(null) で作れます。 出力は [Object: null prototype] {} で、toString などを持ちません。辞書として使うなら、後述の Map も候補です。

キーがあるか確かめる（in・Object.hasOwn）

const s = { a: 1, b: undefined };
console.log("a" in s, "b" in s, "toString" in s);          // → true true true
console.log(Object.hasOwn(s, "b"), Object.hasOwn(s, "toString")); // → true false
console.log(s.b !== undefined, s.c !== undefined);          // → false false

「キーがあるか」は Object.hasOwn、「値が入っているか」は !== undefined と、目的で使い分けます。

キー・値を列挙する（keys・values・entries・fromEntries）

const stock = { pen: 10, note: 3, eraser: 0 };
console.log(Object.keys(stock));    // → [ 'pen', 'note', 'eraser' ]
console.log(Object.values(stock));  // → [ 10, 3, 0 ]
console.log(Object.entries(stock)); // → [ [ 'pen', 10 ], [ 'note', 3 ], [ 'eraser', 0 ] ]

for (const [k, v] of Object.entries(stock)) {
  console.log(`${k}: ${v}`);
}
// → pen: 10
//   note: 3
//   eraser: 0

// 在庫0を除く
Object.fromEntries(Object.entries(stock).filter(([, v]) => v > 0));
// → { pen: 10, note: 3 }

// 値を2倍にする
Object.fromEntries(Object.entries(stock).map(([k, v]) => [k, v * 2]));
// → { pen: 20, note: 6, eraser: 0 }

// Map からオブジェクトへ
Object.fromEntries(new Map([["x", 1], ["y", 2]])); // → { x: 1, y: 2 }

オブジェクトには map や filter がないので、entries で配列にしてから加工し、fromEntries で戻します。 Object.keys(obj).length でプロパティ数がわかります。

for...in と Object.keys の違い

const parent = { inherited: 1 };
const child = Object.create(parent);
child.own = 2;

const keys = [];
for (const k in child) keys.push(k);
console.log(keys, Object.keys(child)); // → [ 'own', 'inherited' ] [ 'own' ]

for...in は継承したキーまで回り、Object.keys は自分のキーだけを返します。 意図しないキーが混ざらないよう、for (const [k, v] of Object.entries(obj)) を基本にすると安心です。

キーの列挙順のルール

const order = { b: 1, 2: "two", a: 2, 1: "one", "-1": "minus", "01": "zero-one", [Symbol("s")]: 3 };
console.log(Object.keys(order));
// → [ '1', '2', 'b', 'a', '-1', '01' ]
console.log(Reflect.ownKeys(order));
// → [ '1', '2', 'b', 'a', '-1', '01', Symbol(s) ]

"-1" や "01" は「整数のインデックス」とは見なされないため、文字列として追加順に並びます。 会員番号のような数字をキーにすると、追加順ではなく数値順に並び替わります。順番を保ちたいときは、キーに接頭辞を付ける（"id_1"）か、Mapを使います（Mapは数値キーも含めて常に追加順で、[...new Map([["b",1],[2,"x"],["a",2],[1,"y"]]).keys()] は [ 'b', 2, 'a', 1 ] でした）。

オブジェクトを結合する（スプレッド・Object.assign）

const def = { theme: "light", size: 12, nested: { a: 1 } };
const user = { size: 14, nested: { b: 2 } };
console.log({ ...def, ...user });
// → { theme: 'light', size: 14, nested: { b: 2 } }

const target = { x: 1 };
const ret = Object.assign(target, { y: 2 });
console.log(ret === target, target); // → true { x: 1, y: 2 }

console.log({ ...def, size: undefined }.size); // → undefined
console.log({ ...null, ...undefined, a: 1 });   // → { a: 1 }

結合は後ろに書いたほうが優先され、入れ子のオブジェクトは「丸ごと置き換え」になります。 上の例では nested が { a: 1, b: 2 } にはならず { b: 2 } です。入れ子までマージしたいときは、その階層もスプレッドで書きます（nested: { ...def.nested, ...user.nested }）。また undefined を明示したキーは既定値を上書きするので、設定値をマージするときは undefined のキーを先に取り除くと意図どおりになります。

浅いコピーと深いコピー（structuredClone）

const src = { name: "会員A", tags: ["新規"], profile: { rank: 1 } };
const shallow = { ...src };
shallow.name = "変更";
shallow.tags.push("追加");
shallow.profile.rank = 9;
console.log(src);
// → { name: '会員A', tags: [ '新規', '追加' ], profile: { rank: 9 } }

const src2 = { name: "会員A", tags: ["新規"], profile: { rank: 1 } };
const deep = structuredClone(src2);
deep.tags.push("追加");
deep.profile.rank = 9;
console.log(src2);
// → { name: '会員A', tags: [ '新規' ], profile: { rank: 1 } }

浅いコピーは1階層目だけを複製し、入れ子の配列・オブジェクトは元と共有します。 name の変更は元に影響しませんが、tags と profile は元まで変わりました。入れ子まで別物にしたいときは structuredClone を使います。

const a = { x: { y: 1 } };
console.log({ ...a }.x === a.x, Object.assign({}, a).x === a.x, structuredClone(a).x === a.x);
// → true true false

structuredClone と JSON の結果を型ごとに比較（実測）

structuredClone(値) と JSON.parse(JSON.stringify(値)) に、14種類の値を入れた結果です（Node.js 22.22.2）。

データ（文字列・数値・配列・素のオブジェクト・Date・Map・Set）を深くコピーするなら structuredClone が最も多くの型を正しく扱えます。 JSON方式はDateが文字列になり、Map・Set・undefined が消えるため、APIに送るためのJSONを作るとき以外は structuredClone を選びます。

どのコピー方法を選ぶかの判断フロー

flowchart TD
  A[コピーしたいオブジェクト] --> B{入れ子のオブジェクトや配列を書き換える？}
  B -- いいえ --> C["浅いコピー { ...obj }"]
  B -- はい --> D{関数・DOM要素を含む？}
  D -- はい --> E[必要な部分だけ手で組み立てる]
  D -- いいえ --> F{クラスのメソッドを使い続けたい？}
  F -- はい --> G[クラスに clone メソッドを用意する]
  F -- いいえ --> H["structuredClone(obj)"]

クラスのインスタンスをスプレッドでコピーした場合も、メソッドはコピーされません。

class Member {
  constructor(n) { this.n = n; }
  greet() { return "hi " + this.n; }
}
const mem = new Member("鈴木");
const sp = { ...mem };
console.log(sp instanceof Member, typeof sp.greet); // → false undefined

// プロトタイプごと浅くコピーする書き方
const cp = Object.assign(Object.create(Object.getPrototypeOf(mem)), mem);
console.log(cp.greet()); // → hi 鈴木

オブジェクトを比較する（===・isDeepStrictEqual・Object.is）

import { isDeepStrictEqual } from "node:util";

const c1 = { a: 1, b: { c: 2 } };
const c2 = { a: 1, b: { c: 2 } };
console.log(c1 === c2, c1 == c2);                          // → false false
console.log(JSON.stringify(c1) === JSON.stringify(c2));    // → true
console.log(JSON.stringify({ a: 1, b: 2 }) === JSON.stringify({ b: 2, a: 1 })); // → false
console.log(isDeepStrictEqual(c1, c2));                    // → true
console.log(isDeepStrictEqual({ a: 1, b: 2 }, { b: 2, a: 1 })); // → true
console.log(Object.is(NaN, NaN), NaN === NaN, Object.is(0, -0), 0 === -0);
// → true false false true

=== は「同じオブジェクトか（参照）」を比べるため、中身が同じでも別に作ったものは false です。 JSON.stringify での比較はキーの順番が違うと false になるので、Node.jsでは util.isDeepStrictEqual、ブラウザでは比較関数を自作するかライブラリを使います。

変更できなくする（freeze・seal・preventExtensions）

// ESモジュール（strict mode）で実行
const f = Object.freeze({ a: 1, inner: { b: 2 } });
f.a = 99;      // → TypeError: Cannot assign to read only property 'a' of object '#<Object>'
f.c = 3;       // → TypeError: Cannot add property c, object is not extensible
delete f.a;    // → TypeError: Cannot delete property 'a' of #<Object>
f.inner.b = 99; // 入れ子は変更できる
console.log(f, Object.isFrozen(f), Object.isFrozen(f.inner));
// → { a: 1, inner: { b: 99 } } true false

const se = Object.seal({ a: 1 });
se.a = 2;      // 変更はできる
se.b = 3;      // → TypeError: Cannot add property b, object is not extensible
delete se.a;   // → TypeError: Cannot delete property 'a' of #<Object>
console.log(se); // → { a: 2 }

strict mode（ESモジュールやクラスの中）では違反した時点でTypeErrorになり、通常のスクリプトではエラーにならず静かに無視されます。 同じ f.a = 2 を node -e で（strict modeでなく）実行すると、エラーは出ず f は { a: 1 } のままでした。入れ子まで固定したいときは、各階層に Object.freeze を再帰的にかけます。

グループ分けする（Object.groupBy・Map.groupBy）

const tasks = [
  { id: 1, status: "todo", pt: 3 },
  { id: 2, status: "done", pt: 5 },
  { id: 3, status: "todo", pt: 1 },
];

const byStatus = Object.groupBy(tasks, (t) => t.status);
console.log(byStatus);
// → [Object: null prototype] {
//     todo: [ { id: 1, status: 'todo', pt: 3 }, { id: 3, status: 'todo', pt: 1 } ],
//     done: [ { id: 2, status: 'done', pt: 5 } ]
//   }

const bySize = Map.groupBy(tasks, (t) => (t.pt >= 3 ? "large" : "small"));
console.log(bySize);
// → Map(2) {
//     'large' => [ { id: 1, status: 'todo', pt: 3 }, { id: 2, status: 'done', pt: 5 } ],
//     'small' => [ { id: 3, status: 'todo', pt: 1 } ]
//   }

Object.groupBy は配列をキーごとに分けたオブジェクトを返します（ES2024、Node.js 21以降）。 戻り値は Object.create(null) と同じ「継承のないオブジェクト」なので、byStatus.hasOwnProperty(...) は使えません。Object.hasOwn(byStatus, "todo") で確認します。キーをオブジェクトにしたい、追加順を確実に保ちたいときは Map.groupBy を使います。

分割代入・?.・?? で安全に取り出す

const order = { id: 10, customer: { name: "佐藤", address: { city: "横浜" } }, items: [] };
const { id, customer: { name: cname, address: { city } }, note = "なし" } = order;
console.log(id, cname, city, note); // → 10 佐藤 横浜 なし

const cfg = { retry: 0, label: "", nested: null };
console.log(cfg.nested?.value, cfg.missing?.deep.deeper, cfg.fn?.());
// → undefined undefined undefined
console.log(cfg.retry ?? 3, cfg.retry || 3);   // → 0 3
console.log(cfg.label ?? "既定", cfg.label || "既定", cfg.none ?? "既定");
// →  既定 既定（1つ目は空文字のまま）

const cnt = { n: null };
cnt.n ??= 10;  // null/undefined のときだけ代入
cnt.m ||= 5;   // falsy のときだけ代入
console.log(cnt); // → { n: 10, m: 5 }

リトライ回数の 0 や空文字のように「0や空も正しい値」の設定は、|| ではなく ?? で既定値を入れます。

Mapとオブジェクトの使い分け

const kobj = {};
const o = {};
o[1] = "a"; o["1"] = "b"; o[kobj] = "c";
console.log(Object.keys(o));          // → [ '1', '[object Object]' ]

const m = new Map();
m.set(1, "a").set("1", "b").set(kobj, "c");
console.log([...m.keys()], m.size, m.get(kobj)); // → [ 1, '1', {} ] 3 c

console.log("constructor" in {}, new Map().has("constructor")); // → true false
console.log(JSON.stringify(new Map([["a", 1]])));               // → {}
console.log(JSON.stringify(Object.fromEntries(new Map([["a", 1]])))); // → {"a":1}

項目名が決まっているデータはオブジェクト、キーが動的に増減する辞書はMapと考えると選びやすくなります。

よくあるエラーと直し方

DataCloneError は DOMException の一種で、e.name で判別できます。

try {
  structuredClone({ f: () => 1 });
} catch (e) {
  console.log(e.name, e instanceof DOMException); // → DataCloneError true
}

// 直す前：関数を含んだまま複製しようとする
// 直した後：データ部分だけを取り出して複製する
const form = { title: "備品申請", items: [{ name: "椅子" }], validate() { return true } };
const { validate, ...data } = form;
const copy = structuredClone(data);

JSONの循環参照エラーは、Node.jsでは次のように循環している場所まで表示されます。

Converting circular structure to JSON
    --> starting at object with constructor 'Object'
    --- property 'self' closes the circle

よくある質問

Q. Object.keys と Object.entries はどちらを使えばよいですか？ A. キーだけ必要なら keys、キーと値の両方を使うなら entries です。 for (const [k, v] of Object.entries(obj)) と書くと、obj[k] で値を引き直す必要がなく読みやすくなります。

Q. ディープコピーは lodash の cloneDeep と structuredClone のどちらがよいですか？ A. データ（Date・Map・Set・入れ子のオブジェクト）だけなら、追加のライブラリなしで使える structuredClone で足ります。 関数やクラスのインスタンスをそのまま複製したい場合は、structuredClone では扱えないため、clone メソッドを用意するなどの工夫が必要です。

Q. オブジェクトが空かどうかはどう判定しますか？ A. Object.keys(obj).length === 0 で判定できます。 Symbolキーも含めたいときは Reflect.ownKeys(obj).length === 0 を使います。

Q. in と Object.hasOwn はどう違いますか？ A. in は継承したキー（toString など）も true、Object.hasOwn は自分が持つキーだけ true です。 入力データにキーがあるかを確かめる用途では Object.hasOwn が意図どおりに動きます。

まとめ

• 加工は Object.entries → 配列メソッド → Object.fromEntries が基本の型
• キーの存在確認は Object.hasOwn、値の有無は !== undefined、既定値は ??
• スプレッドと Object.assign は浅いコピー。入れ子は共有され、結合では丸ごと置き換わる
• 深いコピーは structuredClone。Date・Map・Set・循環参照も複製でき、関数は DataCloneError
• JSON方式はDateが文字列、Map・Set・undefinedが消えるため、文字列化が目的のときに使う
• 列挙順は「整数キーが数値順 → 文字列キーが追加順」。順番を保つ辞書はMap
• Object.freeze は浅く、strict modeでは違反がTypeErrorになる。グループ分けは Object.groupBy

株式会社RJCでは、JavaScriptのオブジェクト操作を仲間と学び合っています。こうした知識を共有しながら、日々技術を磨いています。

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