TypeScriptでオブジェクトをループ処理する最適な方法：for…inからObject.entriesまで

TypeScriptでの開発において、オブジェクトのプロパティをループ処理（反復処理）する場面は非常に頻繁に発生します。

しかし、JavaScriptと同じ感覚でループを書こうとすると、型安全性の観点からコンパイルエラーに直面することが少なくありません。

本記事では、TypeScriptでオブジェクトを効率的かつ安全にループ処理するための手法を、基本から最新のベストプラクティスまで網羅して解説します。

開発現場で即座に役立つ、型定義の扱い方やエラーの回避策を具体的に見ていきましょう。

TypeScriptにおけるオブジェクトループの基本と課題

JavaScriptにはオブジェクトをループするための方法がいくつか存在しますが、TypeScriptでは「型の整合性」という高い壁があります。

オブジェクトのキーは実行時に動的に追加される可能性があるため、TypeScriptコンパイラはデフォルトで厳格な判定を行います。

まずは、最も基本的な方法である for...in ループの問題点から確認していきます。

for…in ループの特性と注意点

for...in は、オブジェクトのプロパティを反復するための最も伝統的な構文です。

しかし、TypeScriptでこれを使用する場合、インデックス（キー）の型が string として扱われるという制約があります。

以下のコード例で、その挙動を確認してみましょう。

// ユーザー情報を定義
const user = {
  id: 1,
  name: "田中太郎",
  role: "admin"
};

// for...in でループ処理を試みる
for (const key in user) {
  // ここでエラーが発生する可能性がある
  // Element implicitly has an 'any' type because expression of type 'string' can't be used to index type
  console.log(`${key}: ${user[key as keyof typeof user]}`);
}

id: 1
name: 田中太郎
role: admin

上記のコードでは、key が単なる string 型として推論されるため、user[key] というアクセスが安全ではないと判定されます。

これを回避するには、as keyof typeof user のような型アサーションが必要になります。

また、for...in はプロトタイプチェーン上の継承されたプロパティまで取得してしまうという欠点があります。

そのため、現代のTypeScript開発においては、次に紹介する Object 静的メソッドを使用する方法が推奨されます。

Objectメソッドを利用したループ処理

ES2015（ES6）以降、JavaScriptではオブジェクトを配列に変換して処理するメソッドが一般的になりました。

これらのメソッドをTypeScriptで活用することで、より安全にループを記述できます。

Object.keys() によるキーの取得

Object.keys() は、オブジェクトが持つ列挙可能なプロパティ名を配列として返します。

TypeScriptにおいて Object.keys() を使う際、返り値が string[] になる点に注意が必要です。

const config = {
  env: "production",
  port: 8080,
  debug: false
};

// Object.keys を使用したループ
Object.keys(config).forEach((key) => {
  // key は string 型として扱われる
  // config[key] と書くとエラーになるため型アサーションを使用
  const k = key as keyof typeof config;
  console.log(`Key: ${k}, Value: ${config[k]}`);
});

Key: env, Value: production
Key: port, Value: 8080
Key: debug, Value: false

なぜ Object.keys() の返り値が (keyof T)[] ではなく string[] なのでしょうか。

それは、TypeScriptの「構造的部分型（Structural Subtyping）」という仕様により、定義した型以外のプロパティがオブジェクトに含まれている可能性があるからです。

Object.values() による値の直接取得

キーが必要なく、値だけを処理したい場合は Object.values() が最適です。

このメソッドは、指定したオブジェクトが持つ値の配列を返します。

const scores = {
  math: 90,
  english: 85,
  science: 95
};

// 値だけを取得して合計を計算する
const total = Object.values(scores).reduce((acc, curr) => acc + curr, 0);
console.log(`合計点: ${total}`);

合計点: 270

Object.values() の利点は、返り値の型が自動的に値のユニオン型として推論されることです。

上記の例では、戻り値は number[] となり、非常に扱いやすくなります。

Object.entries() によるキーと値のセット取得

キーと値の両方を同時に扱いたい場合に最も便利なのが Object.entries() です。

これは [key, value] のペアからなる配列を返します。

const statusMap = {
  200: "Success",
  404: "Not Found",
  500: "Internal Server Error"
};

// 分割代入を組み合わせてループ処理を行う
for (const [key, value] of Object.entries(statusMap)) {
  console.log(`Status ${key} is ${value}`);
}

Status 200 is Success
Status 404 is Not Found
Status 500 is Internal Server Error

ただし、ここでも key は string 型になります。

もし数値のキーを期待していても、Object.entries() の仕様上、キーは文字列として取得される点に注意してください。

TypeScriptで型安全にループするためのテクニック

標準の Object.keys() などの挙動を理解したところで、より型安全に、かつスマートにループを書くためのテクニックを紹介します。

型アサーションの適切な利用

最も手軽な解決策は、as keyof typeof obj を使用することです。

特定のオブジェクトに対してループを回すことが確定している場合、この方法は非常に実用的です。

interface Product {
  name: string;
  price: number;
  category: string;
}

const item: Product = {
  name: "最新スマホ",
  price: 120000,
  category: "ガジェット"
};

// 型を明示的にキャストして安全にアクセスする
(Object.keys(item) as (keyof Product)[]).forEach((key) => {
  console.log(`${key}: ${item[key]}`);
});

汎用的な型安全ユーティリティ関数の作成

何度も型アサーションを書くのは手間がかかり、コードの見通しも悪くなります。

そこで、型安全なキー取得を可能にするユーティリティ関数を定義しておくのがおすすめです。

/**
 * 型安全な Object.keys
 */
export const getKeys = <T extends object>(obj: T): (keyof T)[] => {
  return Object.keys(obj) as (keyof T)[];
};

/**
 * 型安全な Object.entries
 */
export const getEntries = <T extends object>(obj: T): [keyof T, T[keyof T]][] => {
  return Object.entries(obj) as [keyof T, T[keyof T]][];
};

// 使用例
const settings = {
  isAutoSave: true,
  interval: 300,
  theme: "dark" as const
};

getKeys(settings).forEach((key) => {
  // key は正確に "isAutoSave" | "interval" | "theme" 型となる
  console.log(settings[key]);
});

このようにラッパー関数を用意することで、呼び出し側で冗長な型定義を記述する必要がなくなります。

特に大規模なプロジェクトでは、共有ライブラリとして定義しておくと開発効率が劇的に向上します。

各ループ処理の比較と使い分け

これまで紹介した手法には、それぞれ適したユースケースがあります。

状況に応じて最適な方法を選択できるよう、以下の比較表を参考にしてください。

高度なループ処理：Record型とMap

TypeScriptにおいて、柔軟なオブジェクトを扱う際には Record<K, T> 型や Map オブジェクトの使用も検討すべきです。

Record型のループ処理

Record<string, T> のような型定義であれば、Object.entries() との親和性が非常に高くなります。

type UserRole = "admin" | "editor" | "viewer";

const permissions: Record<UserRole, boolean> = {
  admin: true,
  editor: true,
  viewer: false
};

// Record 型のループ
for (const [role, isAllowed] of Object.entries(permissions)) {
  // role は string ですが、ビジネスロジックで安全に扱える
  if (isAllowed) {
    console.log(`${role} has access.`);
  }
}

Mapオブジェクトの活用

もし、データの順序を保証したい場合や、キーとしてオブジェクト自体を使いたい場合は、通常のオブジェクトではなく Map クラスを使用します。

Mapは標準で反復可能（Iterable）であるため、TypeScriptとの相性が抜群です。

const priceList = new Map<string, number>([
  ["Apple", 150],
  ["Banana", 100],
  ["Cherry", 300]
]);

// Map のループは非常に直感的
for (const [name, price] of priceList) {
  console.log(`${name}: ${price}円`);
}

Mapを使用すれば、TypeScriptは name が string、price が number であることを完璧に推論します。

頻繁に要素の追加や削除、およびループ処理を行うデータ構造であれば、オブジェクトよりも Map を選ぶのが2026年現在のモダンな設計と言えるでしょう。

パフォーマンスに関する考察

数万件規模のプロパティを持つ巨大なオブジェクトをループする場合、パフォーマンスも考慮する必要があります。

一般的に、for...in よりも Object.keys().forEach() や通常の for ループの方が高速である傾向があります。

しかし、近年のJavaScriptエンジン（V8など）は高度に最適化されており、通常のビジネスアプリケーション開発においてこの差が問題になることは稀です。

パフォーマンスを優先してコードの可読性や型安全性を損なうよりも、「意図が伝わりやすく、型エラーが起きにくいコード」を優先すべきです。

よくあるエラーと解決策

ループ処理の実装中によく遭遇するエラーとその回避方法を整理します。

1. Element implicitly has an 'any' type...

これは、動的な文字列をインデックスとして使用した際に発生します。

解決策：前述の as keyof typeof obj を使用するか、型ガード関数を実装します。

2. 列挙不可能なプロパティが無視される

Object.keys() などは、enumerable: false で定義されたプロパティを列挙しません。

解決策：すべてのプロパティ（シンボルを含む）が必要な場合は Reflect.ownKeys() を検討してください。

3. 配列に対して for…in を使ってしまう

配列に対して for...in を使うと、インデックスが「文字列の 0, 1, 2…」として取得され、予期せぬ動作を引き起こします。

解決策：配列のループには必ず for...of または forEach() を使用してください。

まとめ

TypeScriptでオブジェクトをループ処理する際は、JavaScript以上に「型」を意識する必要があります。

本記事で解説した主なポイントを振り返りましょう。

• for...in はプロトタイプ継承の影響を受けるため、極力避ける。
• Object.keys(), Object.values(), Object.entries() を中心に利用する。
• TypeScriptの仕様上、キーは string[] となるため、必要に応じて as keyof でキャストする。
• 頻繁にループを行う場合は、型安全なユーティリティ関数を作成して共通化する。
• 順序や型安全性をより重視するなら Map オブジェクトの利用も検討する。

これらの手法を適切に使い分けることで、バグの少ない堅牢なTypeScriptコードを記述できるようになります。

2026年の開発環境においても、オブジェクトの扱い方は基本でありながら最も重要なスキルの一つです。

正しい知識を持って、快適な型安全ライフを送りましょう。