MENU
  1. ホーム
  2. TypeScript
  3. TypeScriptでの繰り返し処理とエラーハンドリングの実践

TypeScriptでの繰り返し処理とエラーハンドリングの実践

TypeScript

TypeScriptのプログラミングにおいて、繰り返し処理（ループ）は欠かせない重要な要素です。しかし、繰り返し処理の中で発生するエラーや例外を適切に処理しないと、アプリケーションの安定性や信頼性に悪影響を及ぼすことがあります。特に、非同期処理や複数のAPIリクエストを扱う際には、エラーハンドリングを正しく実装することが極めて重要です。本記事では、TypeScriptを使用した繰り返し処理におけるエラーハンドリングの方法を、実践的な例を交えながら解説していきます。

目次

繰り返し処理の基本


繰り返し処理は、同じ操作を複数回実行するために使われる構文です。TypeScriptでは、for、while、forEachなどの構文を使用して繰り返しを実現できます。

forループ


最も基本的な繰り返し構文で、指定した条件が満たされるまで繰り返しを行います。例えば、次のようにインデックスを使ったカウント処理が行えます。

for (let i = 0; i < 5; i++) {
  console.log(i);
}

whileループ


指定した条件が真である間、処理を繰り返します。条件が最初に評価されるため、無限ループに陥らないように注意が必要です。

let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}

forEachループ


配列の各要素に対して一度だけ処理を行います。非同期処理との組み合わせには注意が必要で、後述するエラーハンドリングの課題があります。

const array = [1, 2, 3, 4, 5];
array.forEach(item => {
  console.log(item);
});

これらの基本的なループ構文は、エラーハンドリングと組み合わせることでより強力なコードを実現できます。次のセクションでエラーハンドリングの基礎を解説します。

エラーハンドリングの基礎


エラーハンドリングとは、プログラム実行中に発生する予期しないエラーや例外に対処するための方法です。TypeScriptでは、主にtry-catch構文を使用してエラーハンドリングを行います。これにより、エラーが発生した際にアプリケーションが強制終了するのを防ぎ、適切な処理を実行できます。

try-catch構文


try-catchは、エラーハンドリングの最も基本的な構文です。tryブロック内のコードがエラーを発生させた場合、catchブロックがそのエラーをキャッチし、適切な処理を行います。

try {
  // エラーが発生する可能性のあるコード
  let result = riskyOperation();
  console.log(result);
} catch (error) {
  // エラーを処理
  console.error('エラーが発生しました:', error);
}

throw文


throwを使うことで、開発者自身が意図的にエラーを発生させることができます。これにより、特定の条件が満たされない場合にエラーを明示的に発生させ、適切なエラーハンドリングを実装できます。

function riskyOperation() {
  if (/* 条件 */) {
    throw new Error('条件が満たされていません');
  }
  return '正常な結果';
}

カスタムエラー


独自のエラーメッセージを作成するためには、Errorクラスを継承してカスタムエラーを作成することができます。これにより、エラーの原因をより詳しく説明することが可能です。

class CustomError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "CustomError";
  }
}

try {
  throw new CustomError('カスタムエラーが発生しました');
} catch (error) {
  console.error(error.name + ': ' + error.message);
}

エラーハンドリングの基礎を理解することで、繰り返し処理におけるエラー処理の準備が整います。次に、繰り返し処理とエラーハンドリングを組み合わせた実践的な例を見ていきましょう。

繰り返し処理におけるエラーハンドリングの実践


繰り返し処理にエラーハンドリングを組み込むことで、エラーが発生した場合でも安全に処理を続行することが可能です。繰り返し処理では、ループ内でエラーが発生しても他のループ処理が中断されないようにすることが重要です。ここでは、forやwhileループを使用したエラーハンドリングの実践例を紹介します。

forループでのエラーハンドリング


以下の例では、forループ内でエラーが発生しても、try-catchを用いてエラーをキャッチし、処理が止まらないようにしています。これにより、全てのループを確実に実行し、エラーがあった場合にはエラーメッセージを表示します。

const items = [1, 2, 'error', 4, 5];

for (let i = 0; i < items.length; i++) {
  try {
    // エラーが発生する可能性がある処理
    if (typeof items[i] !== 'number') {
      throw new Error('数値ではありません');
    }
    console.log('処理成功:', items[i]);
  } catch (error) {
    console.error('エラーが発生しました:', error.message);
  }
}

このコードでは、リストの中に数値以外の値（’error’）が含まれている場合にエラーを発生させますが、catchブロックがそれをキャッチするため、ループ全体が中断されることなく処理が進行します。

whileループでのエラーハンドリング


whileループにおいても、try-catch構文を使用して同様にエラーを処理できます。whileループは条件が真である間繰り返すため、条件に基づいたエラーハンドリングが必要です。

let i = 0;
const data = [10, 'error', 30, 40];

while (i < data.length) {
  try {
    if (typeof data[i] !== 'number') {
      throw new Error(`無効なデータ: ${data[i]}`);
    }
    console.log(`データ処理中: ${data[i]}`);
  } catch (error) {
    console.error('エラー:', error.message);
  } finally {
    i++; // インデックスを進める
  }
}

この例では、whileループの中でデータを処理していますが、エラーが発生しても必ずインデックスが進められ、ループが停止することなく次のデータの処理を続けられます。

繰り返し処理でエラーが発生した場合に処理を継続できるようにすることは、安定したアプリケーションを作成する上で重要です。次のセクションでは、さらに高度な非同期処理におけるエラーハンドリングについて詳しく見ていきます。

forループでのエラーハンドリング


forループは、繰り返し処理を効率的に行うための基本的な構文です。しかし、ループ内でエラーが発生した場合、それを適切に処理しないと、アプリケーション全体の動作が停止する可能性があります。ここでは、forループ内でのエラーハンドリングの具体例を紹介し、エラーが発生しても処理が止まらないようにする方法を説明します。

基本的なforループでのエラーハンドリング


forループの中でエラーが発生する可能性がある場合、try-catch構文を使用してエラーをキャッチし、適切に処理することが重要です。以下は、配列内の要素をループ処理し、エラーが発生してもループを継続する例です。

const items = [1, 2, 'error', 4, 5];

for (let i = 0; i < items.length; i++) {
  try {
    // 数値以外の要素があればエラーを投げる
    if (typeof items[i] !== 'number') {
      throw new Error(`無効なデータ: ${items[i]}`);
    }
    console.log(`処理成功: ${items[i]}`);
  } catch (error) {
    console.error(`エラーが発生しました: ${error.message}`);
  }
}

このコードでは、配列内に数値以外の要素があるとエラーを発生させ、catchブロックでエラーを処理します。重要なのは、エラーが発生してもループ全体が中断されることなく、次の要素の処理が続けられる点です。これにより、アプリケーションの動作が安定します。

エラー発生時の処理の分岐


場合によっては、エラーが発生した際に単にログを出力するだけでなく、異なるアクションを取る必要があります。たとえば、特定のエラーが発生した場合に修正処理を行ったり、スキップするなどの対応が考えられます。

const data = [10, 20, 'invalid', 40, 50];

for (let i = 0; i < data.length; i++) {
  try {
    if (typeof data[i] !== 'number') {
      throw new Error(`無効なデータ: ${data[i]}`);
    }
    console.log(`データ処理: ${data[i]}`);
  } catch (error) {
    console.error(`エラー: ${error.message}`);
    // エラー発生時に特定の処理を実行
    if (error.message.includes('無効なデータ')) {
      console.log(`データスキップ: ${data[i]}`);
    }
  }
}

この例では、エラーが発生したときにメッセージの内容に基づいて、処理をスキップするかどうかを判断しています。このようにして、エラーハンドリングの際に柔軟な対応を行うことが可能です。

パフォーマンスへの影響


forループでエラーハンドリングを頻繁に行う場合、パフォーマンスへの影響も考慮する必要があります。エラーが発生するたびに処理が一旦中断され、キャッチ処理が行われるため、エラー処理が頻繁に発生する場合には処理速度が低下することがあります。そのため、エラーハンドリングの設計では、処理の適切な分岐やエラーチェックの効率化が求められます。

次のセクションでは、非同期処理（async/await）におけるエラーハンドリングの実践について詳しく見ていきます。非同期処理は繰り返し処理と組み合わせることが多く、特にAPI呼び出しやデータベース操作などにおいて、適切なエラーハンドリングが必要です。

async/awaitを使った非同期処理のエラーハンドリング


非同期処理は、TypeScriptでよく利用される強力な手法で、特に外部APIの呼び出しやファイル操作など、時間のかかる処理に対して使用されます。async/awaitを用いることで、非同期処理を直感的に記述できますが、その際のエラーハンドリングも重要です。このセクションでは、async/awaitを使った非同期処理におけるエラーハンドリングの具体例を見ていきます。

基本的なasync/awaitの構文


async関数は、必ずawaitキーワードを使用することで、Promiseの結果が返ってくるまで処理を待機することができます。これにより、従来のthenやcatchを使った非同期処理よりもシンプルに記述可能です。

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('データの取得に失敗しました:', error);
  }
}

この例では、fetch関数を用いて外部APIからデータを取得していますが、awaitによって非同期処理の完了を待っています。エラーが発生した場合にはcatchブロックでエラーメッセージを出力し、アプリケーションが停止するのを防ぎます。

ループ内でのasync/awaitのエラーハンドリング


async/awaitをループ内で使用する場合、特定の非同期処理に対してエラーハンドリングを行うことが可能です。以下の例では、forループ内で非同期処理を行い、エラーが発生した際に適切に処理を続ける方法を示しています。

const urls = ['https://api.example.com/1', 'https://api.example.com/2', 'https://api.example.com/invalid'];

async function fetchMultipleData() {
  for (let i = 0; i < urls.length; i++) {
    try {
      const response = await fetch(urls[i]);
      if (!response.ok) {
        throw new Error(`HTTPエラー: ${response.status}`);
      }
      const data = await response.json();
      console.log(`データ取得成功: ${data}`);
    } catch (error) {
      console.error(`エラー発生 (${urls[i]}): ${error.message}`);
    }
  }
}

fetchMultipleData();

このコードでは、複数のAPIエンドポイントからデータを取得しています。各リクエストに対してエラーハンドリングを個別に行うことで、あるエンドポイントでエラーが発生しても、他のエンドポイントのデータ取得には影響を与えないようにしています。

Promise.allを使った並列処理とエラーハンドリング


Promise.allは、複数の非同期処理を同時に実行するために使用されます。これにより、全ての処理が完了するまで待機し、効率的に複数のAPIリクエストを処理できます。しかし、1つでもエラーが発生すると全体の処理が停止してしまうため、エラーハンドリングには注意が必要です。

async function fetchAllData() {
  const requests = urls.map(url => fetch(url).then(response => {
    if (!response.ok) {
      throw new Error(`HTTPエラー: ${response.status}`);
    }
    return response.json();
  }).catch(error => {
    console.error(`エラー発生 (${url}): ${error.message}`);
  }));

  const results = await Promise.all(requests);
  console.log('全てのデータ取得完了:', results);
}

fetchAllData();

この例では、Promise.allを使って全ての非同期処理を並列に実行していますが、各リクエストごとにエラーハンドリングを行っています。エラーが発生した場合でも他の処理には影響せず、全体が完了するまで待機します。

async/awaitでのfinallyの活用


finallyブロックを使用することで、エラーハンドリングの後に必ず実行される処理を定義できます。たとえば、リソースの解放や状態のリセットを行いたい場合に役立ちます。

async function fetchDataWithFinally() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log('データ取得成功:', data);
  } catch (error) {
    console.error('エラー発生:', error.message);
  } finally {
    console.log('非同期処理完了');
  }
}

fetchDataWithFinally();

このコードでは、finallyブロックを使って非同期処理が完了したことを通知しています。エラーが発生してもfinallyブロックは必ず実行されるため、クリーンアップ処理などを安全に行うことができます。

次のセクションでは、Promise.allとエラーハンドリングについてさらに詳しく見ていきます。複数の非同期処理をまとめて扱う際の課題と解決策を考察します。

Promise.allとエラーハンドリング


Promise.allは、複数の非同期処理を一括して管理できる強力な機能です。全てのPromiseが解決されるのを待つか、いずれか1つのPromiseが拒否（エラー）されると即座にエラーが返されます。しかし、すべてのPromiseを処理する際に1つのエラーが原因で他のPromiseが中断される可能性があるため、エラーハンドリングをしっかり実装することが重要です。

Promise.allの基本構文


Promise.allは、複数のPromiseを引数に取り、それぞれの処理が完了するまで待機します。全てが正常に完了すると結果が配列として返されますが、1つでもエラーが発生すると全体が拒否され、処理が途中で止まってしまいます。

const promises = [
  fetch('https://api.example.com/1').then(response => response.json()),
  fetch('https://api.example.com/2').then(response => response.json()),
  fetch('https://api.example.com/invalid').then(response => response.json())
];

Promise.all(promises)
  .then(results => {
    console.log('全てのデータ取得成功:', results);
  })
  .catch(error => {
    console.error('エラーが発生しました:', error);
  });

この例では、3つのAPIリクエストを同時に実行し、それぞれの結果が揃った段階でthenブロックが実行されます。しかし、1つのリクエストが失敗すると、全体がcatchブロックに渡され、エラーが出力されます。

個別のPromiseに対するエラーハンドリング


Promise.allを使うと1つのエラーで全体が失敗するため、個々のPromiseに対してエラーハンドリングを行う必要があります。これを実現するためには、各Promiseの内部でエラー処理を行い、Promise.allに渡す前にそれぞれのエラーを処理します。

const promises = [
  fetch('https://api.example.com/1').then(response => response.json()).catch(error => `エラー: ${error.message}`),
  fetch('https://api.example.com/2').then(response => response.json()).catch(error => `エラー: ${error.message}`),
  fetch('https://api.example.com/invalid').then(response => response.json()).catch(error => `エラー: ${error.message}`)
];

Promise.all(promises)
  .then(results => {
    console.log('結果:', results);
  });

この例では、各Promiseに対してcatchを適用し、個別にエラーを処理しています。これにより、エラーが発生したとしても他のPromiseには影響を与えず、すべてのPromiseの結果を確認できます。Promise.allでは、エラー発生時に特定の処理を行いつつ、他の非同期処理を続行する場合にこの方法が有効です。

Promise.allSettledによる包括的なエラーハンドリング


Promise.allSettledは、全てのPromiseが完了するまで待機し、成功したものと失敗したものの両方を結果として返します。これにより、すべてのPromiseの状態を確認できるため、部分的に成功した結果を扱う場合に非常に便利です。

const promises = [
  fetch('https://api.example.com/1').then(response => response.json()),
  fetch('https://api.example.com/2').then(response => response.json()),
  fetch('https://api.example.com/invalid').then(response => response.json())
];

Promise.allSettled(promises)
  .then(results => {
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`成功 [${index}]:`, result.value);
      } else {
        console.error(`失敗 [${index}]:`, result.reason);
      }
    });
  });

この例では、Promise.allSettledを使って、各Promiseが成功したか失敗したかを個別に確認しています。fulfilledの場合は成功したデータを、rejectedの場合はエラーの理由を出力することで、エラーが発生しても全体の進行を妨げることなく処理を続行できます。

エラーハンドリングの最適化


Promise.allやPromise.allSettledを使用する際は、エラーハンドリングの最適化を行うことで、アプリケーションの堅牢性を向上させることができます。たとえば、エラーログの記録や失敗時の再試行メカニズムを組み込むことで、エラーが発生しても自動的にリカバリする処理を追加することが可能です。また、特定のエラーに対して異なるアクションを取ることも考えられます。

次のセクションでは、forEachにおけるエラーハンドリングの限界について詳しく見ていきます。forEachを使用する際の制約と、それを克服するための方法を考察します。

forEachでのエラーハンドリングの限界


forEachは配列の要素を順番に処理するための便利なメソッドですが、エラーハンドリングにおいては幾つかの制約があります。特に、forEachは非同期処理との相性が悪く、awaitを使用することができません。また、forEach自体はPromiseを返さないため、エラーが発生してもその処理を適切にキャッチしにくいという問題があります。

forEachでのエラーハンドリングの問題点


forEachメソッドの一番の問題点は、非同期処理を扱う際にawaitが使えないことです。これにより、非同期処理内でエラーが発生しても、forEachはそれを認識できず、通常の同期処理のように振る舞ってしまいます。以下の例は、この問題を示しています。

const urls = ['https://api.example.com/1', 'https://api.example.com/2', 'https://api.example.com/invalid'];

urls.forEach(async (url) => {
  try {
    const response = await fetch(url);
    const data = await response.json();
    console.log(`データ取得成功: ${data}`);
  } catch (error) {
    console.error(`エラー発生 (${url}): ${error.message}`);
  }
});

このコードは一見正しく見えますが、実際にはforEach内のasync関数は意図した通りに動作しません。forEach自体は非同期処理をサポートしていないため、全てのAPI呼び出しが非同期に実行されるものの、その完了を待たずに次の処理が進行してしまいます。これにより、予期しない動作やエラーが発生する可能性が高くなります。

forEachでの非同期処理を避ける方法


非同期処理やエラーハンドリングを正しく行うためには、forEachの代わりにfor...ofやmapを使用することを推奨します。これにより、各非同期処理が完了するのを待つことができ、エラーも適切に処理できます。

for…ofを使った非同期処理


for...ofループを使用すると、awaitを使って非同期処理が完了するのを待つことができるため、エラーハンドリングもスムーズに行えます。

const urls = ['https://api.example.com/1', 'https://api.example.com/2', 'https://api.example.com/invalid'];

async function fetchAllData() {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      const data = await response.json();
      console.log(`データ取得成功: ${data}`);
    } catch (error) {
      console.error(`エラー発生 (${url}): ${error.message}`);
    }
  }
}

fetchAllData();

この例では、for...ofを使用することで、各API呼び出しが順番に行われ、非同期処理が完了するまで次の処理に進まないようになっています。この方法により、非同期処理のエラーも適切にキャッチされます。

Promise.allを使った並列処理


forEachの代わりに、mapでPromiseを生成し、Promise.allでまとめて処理する方法も有効です。これにより、全ての非同期処理が並列に実行され、効率よくデータを取得できます。

const urls = ['https://api.example.com/1', 'https://api.example.com/2', 'https://api.example.com/invalid'];

async function fetchAllData() {
  const promises = urls.map(async (url) => {
    try {
      const response = await fetch(url);
      return await response.json();
    } catch (error) {
      console.error(`エラー発生 (${url}): ${error.message}`);
    }
  });

  const results = await Promise.all(promises);
  console.log('全てのデータ取得完了:', results);
}

fetchAllData();

この例では、Promise.allを使って並列処理を行い、全てのAPIリクエストが完了するまで待機しています。これにより、非同期処理全体のパフォーマンスが向上し、各Promiseのエラーハンドリングも同時に行うことができます。

まとめ


forEachは便利なメソッドですが、非同期処理やエラーハンドリングには不向きです。非同期処理を扱う際には、for...ofやPromise.allを使用することで、エラーハンドリングをより効率的かつ安全に行うことができます。次のセクションでは、エラーログの収集とその重要性について説明し、エラーハンドリングをより効果的にするための実践的なアプローチを見ていきます。

エラーログの重要性


エラーハンドリングにおいて、エラーログを適切に収集し、解析することは非常に重要です。エラーログがあれば、予期しない問題の原因を素早く特定し、対処することが可能になります。また、エラーログは単なるバグ修正のためだけではなく、アプリケーションのパフォーマンスや信頼性を向上させるための貴重なデータを提供します。

エラーログとは何か


エラーログは、システムやアプリケーションが実行中に発生したエラーや例外の記録です。これには、エラーの発生場所、発生時刻、エラーメッセージ、スタックトレースなどの詳細情報が含まれます。これにより、開発者はどこで何が起こったのかを正確に把握することができます。

エラーログを収集する理由


エラーログを収集する理由は以下の通りです。

エラーの迅速な検出


アプリケーションがエラーを起こしても、ユーザーからの報告を待つのではなく、エラーログを解析することで、問題をリアルタイムに検知し、素早く対応することが可能です。

問題の再現性の確保


多くの場合、エラーは特定の条件下でしか発生しません。エラーログがあれば、その条件を再現し、開発環境で問題を再現することが容易になります。再現性が高いほど、修正も迅速かつ効果的になります。

トレンドの把握


定期的にエラーログを確認することで、どの部分に頻繁にエラーが発生しているか、特定のエラーがどのバージョンで増えているかなどのトレンドを把握できます。これにより、根本的な改善策を講じることが可能になります。

エラーログの実装方法


TypeScriptでエラーログを収集する際には、console.errorを使うのが最も基本的な方法ですが、実際のプロジェクトではより高度なロギングシステムを利用することを推奨します。たとえば、外部のロギングサービスや、ログファイルへの出力を行うことで、エラーデータを安全に保存・管理することができます。

try {
  // エラーが発生する可能性のある処理
  throw new Error('予期しないエラーが発生しました');
} catch (error) {
  console.error('エラーメッセージ:', error.message);
  console.error('スタックトレース:', error.stack);
  // ここでエラーログを外部システムに送信するなどの処理を実装可能
}

外部ロギングサービスの利用


エラーログを単にコンソールに出力するだけでは、リアルタイムで問題を把握するのが難しい場合があります。そのため、SentryやLoggly、Datadogなどの外部ロギングサービスを利用することが推奨されます。これらのツールは、エラーログをクラウド上で管理し、リアルタイムにエラーの発生を監視・通知する機能を提供します。

import * as Sentry from '@sentry/browser';

Sentry.init({ dsn: 'https://example@sentry.io/project-id' });

try {
  // エラーが発生する可能性のある処理
  throw new Error('外部サービスへのエラーログ送信');
} catch (error) {
  Sentry.captureException(error);
  console.error('エラーログがSentryに送信されました:', error.message);
}

このコードは、Sentryという外部ロギングサービスを使用してエラーログを送信する例です。エラーが発生した際に自動的にSentryにログが送信され、問題が即座に検知されます。

エラーログの解析と応用


エラーログを単に収集するだけでなく、それを継続的に解析し、頻繁に発生するエラーを特定することが重要です。エラーログの解析結果を基に、アプリケーションのコード品質やパフォーマンスを改善する取り組みが可能になります。

次のセクションでは、実際の開発現場において、繰り返し処理や非同期処理でのエラーハンドリングがどのように応用されているかについて、具体的な事例を紹介します。

実務での応用例


繰り返し処理や非同期処理におけるエラーハンドリングは、実際の開発現場で非常に重要な役割を果たしています。ここでは、TypeScriptを使ったエラーハンドリングの実務における具体的な応用例をいくつか紹介します。特に、APIの大量リクエスト処理やバッチ処理などでの実践的なエラーハンドリングを解説します。

応用例1: 大量のAPIリクエストの処理


現実の開発では、複数のAPIエンドポイントからデータを取得し、それらを統合して処理することがよくあります。しかし、各リクエストに対してエラーハンドリングを行わないと、一部のリクエストが失敗した場合に全体の処理が中断されてしまうリスクがあります。

例えば、以下のようにPromise.allSettledを使って大量のAPIリクエストを処理し、エラーが発生しても全体が中断されないようにすることができます。

const endpoints = [
  'https://api.example.com/data1',
  'https://api.example.com/data2',
  'https://api.example.com/data3'
];

async function fetchData() {
  const requests = endpoints.map(url => fetch(url).then(response => response.json()));

  const results = await Promise.allSettled(requests);
  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`データ取得成功 [${index}]:`, result.value);
    } else {
      console.error(`データ取得失敗 [${index}]:`, result.reason);
    }
  });
}

fetchData();

このように、すべてのAPIリクエストを実行しつつ、それぞれの結果に応じたエラーハンドリングを行うことで、エラーが発生しても他の処理を止めることなく安全に進行させることができます。このアプローチは、例えばバッチ処理で多数の外部サービスと連携する際に有効です。

応用例2: バッチ処理におけるエラーハンドリング


企業システムなどでは、夜間バッチ処理で大量のデータを処理するケースが多くあります。たとえば、何万件ものデータをデータベースから取得し、それを順次処理していく場合、エラーが発生してもその時点で処理が止まることなく、エラーハンドリングをしながら進める必要があります。

以下は、データベースから取得したデータをfor...ofループを使って処理しつつ、エラーが発生した場合にはログを出力し、処理を続行する例です。

async function processBatchData(data: any[]) {
  for (const item of data) {
    try {
      // データの処理
      if (!item.isValid) {
        throw new Error(`無効なデータ: ${item.id}`);
      }
      console.log(`データ処理成功: ${item.id}`);
    } catch (error) {
      console.error(`エラー発生 (データID: ${item.id}):`, error.message);
      // エラーをログに記録し、次の処理に進む
    }
  }
}

このアプローチでは、各データアイテムを順次処理し、エラーが発生した場合にはキャッチしてログに記録し、処理を続けることができます。これにより、システム全体が停止することなく、エラーを管理しながら大規模なデータ処理を行えます。

応用例3: ユーザーインターフェースの非同期処理


ウェブアプリケーション開発では、フォームの送信やボタン操作に応じて非同期でサーバーにデータを送信し、その結果に応じて画面の更新を行うケースがよくあります。この際、サーバーエラーやネットワークエラーが発生する可能性があり、これをユーザーに適切に通知する必要があります。

以下は、フォーム送信時に非同期でデータをサーバーに送信し、エラーが発生した場合にはユーザーに通知する例です。

async function submitForm(data: any) {
  try {
    const response = await fetch('https://api.example.com/submit', {
      method: 'POST',
      body: JSON.stringify(data),
      headers: { 'Content-Type': 'application/json' }
    });

    if (!response.ok) {
      throw new Error(`サーバーエラー: ${response.status}`);
    }

    const result = await response.json();
    console.log('送信成功:', result);
    // ユーザーに成功メッセージを表示
  } catch (error) {
    console.error('送信エラー:', error.message);
    // ユーザーにエラーメッセージを表示
  }
}

この例では、fetchを使ってフォームデータを送信し、エラーが発生した場合にはユーザーにエラーメッセージを表示する処理が含まれています。このようにして、エラーハンドリングによってユーザー体験を損なわないようにすることができます。

応用例4: リトライ処理の実装


ネットワーク通信が不安定な環境では、一度のリクエストが失敗することがあります。そういった場合、リクエストを再試行するリトライ処理を実装することで、通信エラーの影響を最小限に抑えることができます。以下は、リトライ処理を使った非同期APIリクエストの例です。

async function fetchDataWithRetry(url: string, retries: number = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTPエラー: ${response.status}`);
      }
      const data = await response.json();
      console.log('データ取得成功:', data);
      return data;
    } catch (error) {
      console.error(`リトライ (${i + 1}/${retries}) エラー:`, error.message);
      if (i === retries - 1) {
        throw new Error('リトライ回数を超えました');
      }
    }
  }
}

fetchDataWithRetry('https://api.example.com/data')
  .then(data => console.log('最終結果:', data))
  .catch(error => console.error('最終エラー:', error.message));

この例では、通信エラーが発生した際に最大3回までリクエストを再試行する処理を実装しています。これにより、一時的なネットワーク障害などに対しても、アプリケーションが堅牢に動作することが可能になります。

次のセクションでは、エラーハンドリングにおけるテスト駆動開発(TDD)の効果的な活用について解説します。

テスト駆動開発 (TDD) によるエラーハンドリングの最適化


テスト駆動開発（TDD）は、コードの品質を高め、エラーハンドリングを最適化するために非常に有効な手法です。TDDでは、コードを実装する前にテストケースを作成し、そのテストに基づいて機能を実装していくことで、バグを防ぎ、エラーの発生箇所を正確に把握できるようになります。ここでは、TDDを用いてエラーハンドリングを最適化する方法を説明します。

TDDの基本プロセス


TDDは以下の3つのステップで進行します。

  1. テストを先に書く
    まず、実装する機能や処理に対して、想定されるエラーを含めたテストケースを作成します。これにより、どのようなエラーが発生する可能性があるかを事前に洗い出し、それに対応するコードを書くことができます。
  2. テストを実行して失敗させる
    実装前の段階ではテストは失敗しますが、これはエラー処理を意識した設計のスタート地点です。テストが失敗することで、どのケースでエラーが発生するかを確認できます。
  3. テストに合格するコードを実装する
    テストが想定したエラーパターンを処理できるように、コードを実装します。これにより、エラーが正しくキャッチされ、対応するようになります。

エラーハンドリングのテストケース作成


エラーハンドリングのTDDを実践するためには、まず想定されるエラーに対するテストケースを作成します。以下の例では、APIリクエストに対してエラーハンドリングのテストを行います。

// テストフレームワーク（例えばJest）を使用した例
test('APIリクエストでエラーが発生した場合のハンドリング', async () => {
  // ダミーのfetch関数を作成して、エラーを投げる
  global.fetch = jest.fn(() => Promise.reject(new Error('ネットワークエラー')));

  const response = await fetchDataWithRetry('https://api.example.com/data');

  expect(response).toBeUndefined();
  expect(console.error).toHaveBeenCalledWith(expect.stringContaining('ネットワークエラー'));
});

このテストケースでは、APIリクエスト中にネットワークエラーが発生する状況を模擬し、その際のエラーハンドリングが正しく機能しているかどうかを確認します。fetchDataWithRetry関数に対してテストを行い、エラーが発生した場合に適切にconsole.errorが呼ばれているかどうかも検証しています。

エラーハンドリングを対象としたテストの実装


実際にテストを実行し、エラーハンドリングが適切に機能しているかを確認することで、予期しないエラーが発生してもシステムが正しく動作することを保証できます。以下は、再試行処理を含むAPIリクエストのエラーハンドリングに対する実装の例です。

async function fetchDataWithRetry(url: string, retries: number = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTPエラー: ${response.status}`);
      }
      const data = await response.json();
      return data;
    } catch (error) {
      console.error(`リトライ (${i + 1}/${retries}) エラー: ${error.message}`);
      if (i === retries - 1) {
        throw new Error('リトライ回数を超えました');
      }
    }
  }
}

// TDDテスト
test('fetchDataWithRetryで全てのリトライが失敗する場合', async () => {
  global.fetch = jest.fn(() => Promise.reject(new Error('ネットワークエラー')));

  await expect(fetchDataWithRetry('https://api.example.com/data', 3)).rejects.toThrow('リトライ回数を超えました');
});

このテストは、3回のリトライがすべて失敗した場合に、fetchDataWithRetry関数がエラーメッセージを正しく出力し、例外を投げることを確認します。これにより、エラーハンドリングのロジックが想定通りに動作することを保証できます。

TDDによるエラーハンドリングのメリット


TDDを採用することで、エラーハンドリングが常に期待通りに動作していることを確認しながら開発を進められます。また、テストケースがあることで、将来的にコードが変更された場合でもエラーハンドリングが破壊されていないことを保証できるため、信頼性の高いシステムを構築できます。

  1. エラーが発生するパターンを事前に想定できる
    テストを書く際に、さまざまなエラーシナリオを事前に想定するため、開発後に予期しないエラーが発生するリスクを減らせます。
  2. バグ修正が迅速に行える
    エラーが発生した場合でも、テストケースが失敗するため、どの部分で問題が起きているかを即座に特定し、修正が可能です。
  3. コードの品質向上
    エラーハンドリングを含むコード全体の品質が向上し、予期しない問題に対して堅牢なアプリケーションを提供できます。

次のセクションでは、繰り返し処理とエラーハンドリングの重要なポイントを総括し、記事のまとめに進みます。

まとめ


本記事では、TypeScriptにおける繰り返し処理とエラーハンドリングの実践的な方法を詳しく解説しました。繰り返し処理の基本から、async/awaitやPromise.allなどの非同期処理におけるエラーハンドリング、forEachの限界や実務での応用例まで幅広く取り上げました。また、TDDによるエラーハンドリングの最適化についても触れ、信頼性の高いコードの開発手法を示しました。
エラーハンドリングは、アプリケーションの安定性とユーザー体験を向上させるために欠かせない要素です。適切なエラーハンドリングを実装し、効果的なテストを行うことで、強固で信頼性の高いアプリケーションを構築しましょう。

TypeScript
繰り返し処理 エラーハンドリング TypeScript

コメント

コメントする

目次