MENU
  1. ホーム
  2. TypeScript
  3. TypeScriptでユニオン型を使った例外処理の実践ガイド

TypeScriptでユニオン型を使った例外処理の実践ガイド

TypeScript

TypeScriptにおいて、例外処理はエラーを効果的に扱い、プログラムが予期しない動作を防ぐために重要な要素です。しかし、複数のエラーパターンを処理する際、エラーハンドリングのコードが複雑になりがちです。そこでTypeScriptのユニオン型を活用すると、複数の例外を一元管理し、コードを整理しやすくなります。ユニオン型を使用することで、異なるエラーパターンに対して型安全かつ効率的に対処する方法を学ぶことができます。本記事では、TypeScriptでユニオン型を使って複数の例外を処理する方法を解説し、具体的な実装例やベストプラクティスを紹介していきます。

目次

ユニオン型の基礎

TypeScriptのユニオン型とは、複数の型を一つにまとめ、それぞれの型の値を受け取ることができる型のことです。ユニオン型を使用すると、異なる型の値が許容される変数や関数の引数を定義できるため、柔軟なコードを書けるようになります。

ユニオン型の定義

ユニオン型は、パイプ（|）を使って複数の型を連結して定義します。例えば、string型とnumber型を受け取る変数は次のように宣言します。

let value: string | number;
value = "hello";  // OK
value = 123;      // OK

このように、valueにはstringもnumberも代入することが可能です。

ユニオン型の使用例

ユニオン型を利用することで、例えば次のように関数で複数の引数の型を許容できます。

function printValue(value: string | number) {
  console.log(value);
}

printValue("こんにちは"); // OK
printValue(42);         // OK

この関数printValueは、文字列と数値のどちらの値も受け取ることができ、型を意識せずに利用できるようになります。

ユニオン型の基本を理解することで、より柔軟な例外処理や型定義が可能となり、次に紹介する例外処理においても役立てることができます。

例外処理とユニオン型の関係

TypeScriptでは、例外処理を行う際にさまざまなエラーが発生する可能性があります。これらのエラーを個別に処理するために、try-catch文を使用するのが一般的ですが、複数のエラーパターンを1つのメカニズムでまとめて処理するには、ユニオン型が非常に有効です。

ユニオン型を使用するメリット

ユニオン型を使うことで、異なる型のエラーをまとめて扱うことが可能になります。通常、try-catchブロック内で発生するエラーは、1つの型（例: Error型）に限定されがちですが、ユニオン型を使用することで、さまざまなエラーパターンを型安全に管理することができます。

例えば、次のように複数のエラーパターンを持つ関数の返り値をユニオン型で定義することができます。

type FileError = { message: string; code: number };
type NetworkError = { error: string; statusCode: number };

function fetchData(): FileError | NetworkError {
  // ここで何らかのエラーが発生する可能性がある
  return { message: "ファイルが見つかりません", code: 404 };
}

このように、異なるエラーパターン（ここではFileErrorとNetworkError）をユニオン型で定義することで、複数のエラーパターンに対応できる柔軟な例外処理を実現できます。

ユニオン型による例外処理の柔軟性

ユニオン型を使用することで、複数の例外を一括して管理でき、個別の型ごとの処理を行うことができます。例えば、次のように型ガードを使って異なるエラーパターンに対応した処理を行えます。

function handleErrors(error: FileError | NetworkError) {
  if ("code" in error) {
    console.log(`ファイルエラー: ${error.message}, コード: ${error.code}`);
  } else {
    console.log(`ネットワークエラー: ${error.error}, ステータスコード: ${error.statusCode}`);
  }
}

このように、ユニオン型を使うことで異なるエラーパターンを簡潔に処理でき、コードの可読性と保守性が向上します。これが例外処理におけるユニオン型の大きな利点です。

ユニオン型を使用する例外処理の実装例

TypeScriptのユニオン型を活用して、例外処理をより簡潔かつ型安全に行う実装例を見ていきます。ここでは、複数の異なるエラーが発生する可能性のある関数を定義し、それに対してユニオン型を使用して処理を統一する方法を紹介します。

複数のエラーパターンを持つ関数の実装

例えば、ファイル操作とネットワーク通信が行われるアプリケーションで、これらの操作中に異なるエラーが発生するケースを考えます。以下のように、ユニオン型を使って複数のエラーパターンを管理します。

type FileError = { type: "FileError"; message: string; code: number };
type NetworkError = { type: "NetworkError"; error: string; statusCode: number };

function performOperation(): FileError | NetworkError {
  // 仮に、ここでファイルエラーが発生する場合
  return { type: "FileError", message: "ファイルが見つかりません", code: 404 };
}

この関数performOperationは、ファイル操作やネットワーク通信でエラーが発生した場合に、FileErrorまたはNetworkErrorのいずれかを返すように設計されています。

ユニオン型を使ったエラーの処理

返されたエラーに対して、ユニオン型を活用した例外処理を行います。次のコードでは、エラーの種類に応じて異なる処理を行います。

function handleOperationResult(result: FileError | NetworkError) {
  if (result.type === "FileError") {
    console.log(`ファイルエラー: ${result.message} (コード: ${result.code})`);
  } else if (result.type === "NetworkError") {
    console.log(`ネットワークエラー: ${result.error} (ステータス: ${result.statusCode})`);
  }
}

const result = performOperation();
handleOperationResult(result);

この例では、resultがFileErrorかNetworkErrorかを型ガード（result.typeによる条件分岐）を用いて判断し、適切なメッセージを表示しています。これにより、異なるエラーパターンに対する一貫した処理が可能になります。

実装のメリット

ユニオン型を使用することで、複数のエラーパターンを型安全に管理し、それぞれに応じた処理を実装できるため、次のようなメリットがあります。

  • 型安全：コンパイル時にエラーをチェックでき、実行時の予期しないエラーを減らせる。
  • 可読性向上：複数のエラー処理を一つの関数で簡潔に記述できるため、コードの見通しが良くなる。
  • 拡張性：将来的に新しいエラーパターンが追加されても、ユニオン型に新しい型を追加するだけで対応できる。

このように、ユニオン型を使った例外処理は、複雑なエラーハンドリングを簡潔かつ強力にサポートしてくれます。

TypeScriptのガードを使った型安全な例外処理

ユニオン型を使って例外を統一的に扱う際、TypeScriptの型ガードを活用することで、型安全な例外処理を実現できます。型ガードとは、特定の型に絞り込むためのメカニズムで、ユニオン型の中から適切な型を選び、その型に基づいて処理を行うことができます。

型ガードの基礎

型ガードは、typeofやinstanceofなどの演算子や、特定のプロパティの存在を確認することで実現されます。これにより、ユニオン型に含まれるどの型が実際に利用されているかを判断し、安全に操作できます。

例えば、typeofを使った基本的な型ガードは以下の通りです。

function printValue(value: string | number) {
  if (typeof value === "string") {
    console.log(`文字列: ${value.toUpperCase()}`);
  } else {
    console.log(`数値: ${value.toFixed(2)}`);
  }
}

この例では、valueがstring型かnumber型かをtypeofで判定し、それぞれに適した処理を行っています。

型ガードを使った例外処理

ユニオン型を使った例外処理にも、この型ガードを適用することができます。以下は、ファイルエラーとネットワークエラーを区別して処理する例です。

type FileError = { type: "FileError"; message: string; code: number };
type NetworkError = { type: "NetworkError"; error: string; statusCode: number };

function handleError(error: FileError | NetworkError) {
  if (error.type === "FileError") {
    console.log(`ファイルエラーが発生しました: ${error.message} (コード: ${error.code})`);
  } else if (error.type === "NetworkError") {
    console.log(`ネットワークエラーが発生しました: ${error.error} (ステータス: ${error.statusCode})`);
  }
}

このコードでは、error.typeというプロパティを使って型ガードを行い、それぞれのエラーに対して適切な処理をしています。これにより、ユニオン型の中からエラーの型を特定し、その型に適した操作を型安全に実行できます。

カスタム型ガードの作成

より高度な型ガードとして、カスタム型ガード関数を作成することも可能です。これにより、処理の中で型判定ロジックを簡潔に使い回すことができます。次の例では、isFileErrorというカスタム型ガードを作成しています。

function isFileError(error: FileError | NetworkError): error is FileError {
  return error.type === "FileError";
}

function handleCustomError(error: FileError | NetworkError) {
  if (isFileError(error)) {
    console.log(`カスタムファイルエラー: ${error.message} (コード: ${error.code})`);
  } else {
    console.log(`カスタムネットワークエラー: ${error.error} (ステータス: ${error.statusCode})`);
  }
}

isFileErrorは、引数がFileErrorであるかどうかを判定し、その結果に基づいて型を絞り込みます。このようにカスタム型ガードを使用すると、コードの可読性が向上し、再利用性の高いエラーハンドリングが可能になります。

型安全な例外処理のメリット

  • コンパイル時の安全性：型ガードを使うことで、コンパイル時に型エラーが検出され、予期しないバグを未然に防げます。
  • 可読性の向上：カスタム型ガードを使うと、コードの意図が明確になり、可読性が向上します。
  • メンテナンス性：型ガードを活用したエラーハンドリングは、後から新しいエラーパターンが追加された場合でも、拡張が容易です。

型ガードを活用することで、ユニオン型の例外処理を型安全かつ効率的に実装できます。これにより、エラーハンドリングの際のミスを減らし、堅牢なアプリケーションを開発できます。

カスタムエラー型の設計とユニオン型

TypeScriptで複雑なエラーハンドリングを行う場合、標準のError型だけでなく、カスタムエラー型を作成することが有効です。カスタムエラー型をユニオン型に組み込むことで、特定のエラーシナリオに合わせた柔軟な例外処理が可能になります。この章では、カスタムエラー型の設計と、それをユニオン型に組み込む方法を解説します。

カスタムエラー型の設計

TypeScriptでは、特定のエラーパターンに対応する独自のエラー型を設計できます。これは、標準のError型に加え、追加情報を持たせるために役立ちます。たとえば、次のようにファイルエラーやネットワークエラーに独自の情報を持たせたカスタムエラー型を定義します。

class FileError extends Error {
  constructor(public message: string, public code: number) {
    super(message);
    this.name = "FileError";
  }
}

class NetworkError extends Error {
  constructor(public error: string, public statusCode: number) {
    super(error);
    this.name = "NetworkError";
  }
}

このようにFileErrorとNetworkErrorというカスタムエラー型を定義することで、エラーごとに特定のデータ（例えば、ファイルエラーのcodeやネットワークエラーのstatusCode）を持たせることができます。

ユニオン型への組み込み

これらのカスタムエラー型をユニオン型に組み込むことで、さまざまなエラーに対応した一元的なエラーハンドリングが可能になります。例えば、以下のように複数のカスタムエラー型をユニオン型で扱うことができます。

type CustomError = FileError | NetworkError;

function throwError(): CustomError {
  return new FileError("ファイルが見つかりません", 404);
}

ここでは、CustomErrorというユニオン型にFileErrorとNetworkErrorを含めて、どちらのエラーが発生しても同じように扱えるようにしています。

カスタムエラーの処理

ユニオン型に組み込まれたカスタムエラーは、型ガードを使ってエラーのタイプに応じた処理が行えます。例えば、instanceofを使ってエラーハンドリングを実装します。

function handleCustomError(error: CustomError) {
  if (error instanceof FileError) {
    console.log(`ファイルエラー: ${error.message} (コード: ${error.code})`);
  } else if (error instanceof NetworkError) {
    console.log(`ネットワークエラー: ${error.error} (ステータス: ${error.statusCode})`);
  }
}

const error = throwError();
handleCustomError(error);

このコードでは、instanceofを使って、FileErrorとNetworkErrorを区別して適切に処理しています。この方法により、各エラータイプに対応したカスタム処理が可能になります。

カスタムエラー型のメリット

  • 情報の拡張：エラーに特定の情報を持たせることで、後の処理やデバッグが容易になります。
  • コードの整理：複数のエラーパターンを統一して扱うことで、エラーハンドリングのコードが整理され、可読性が向上します。
  • 型安全：カスタムエラー型をユニオン型に組み込むことで、エラーの処理が型安全になり、ミスが減少します。

カスタムエラー型を設計し、それをユニオン型に組み込むことで、より洗練されたエラーハンドリングを実現できます。これにより、複雑なエラーパターンに対しても、効率的かつ安全に対応できるようになります。

例外処理のベストプラクティス

TypeScriptでユニオン型を使った例外処理を効果的に行うためには、いくつかのベストプラクティスを押さえておくことが重要です。これにより、エラーハンドリングのコードが明確でメンテナンスしやすくなり、予期しないバグを防ぐことができます。この章では、ユニオン型を使った例外処理を最適化するためのベストプラクティスを紹介します。

1. 一貫したエラーハンドリング方針を持つ

エラーハンドリングの一貫性は、コードの可読性と保守性に大きく影響します。ユニオン型を使う場合でも、全てのエラーに対して統一されたアプローチを取ることが重要です。例えば、try-catch文を使う場合、捕捉するエラーの型を明確に定義し、必ずどのようなエラーが発生し得るかを把握した上で対応します。

function executeOperation(): void {
  try {
    // 例外が発生する可能性のある処理
  } catch (error) {
    if (error instanceof FileError || error instanceof NetworkError) {
      handleCustomError(error);  // 統一されたエラーハンドリング
    } else {
      throw new Error("未処理の例外が発生しました");
    }
  }
}

このように、発生する可能性のあるエラーはすべてユニオン型で管理し、それ以外のエラーは適切に処理または再スローするという一貫した方針を持ちましょう。

2. カスタムエラーを適切に設計する

カスタムエラー型を使う際には、必要な情報を適切に含めることが重要です。エラーメッセージに加えて、エラーコードや状況に応じた追加情報を持たせることで、後の処理やデバッグが格段にしやすくなります。

例えば、以下のように詳細なエラーデータを持つエラーを設計できます。

class FileError extends Error {
  constructor(public message: string, public filePath: string, public code: number) {
    super(message);
    this.name = "FileError";
  }
}

このようにカスタムエラーを詳細に設計しておくことで、エラー発生時に適切な対応やログ出力が可能になります。

3. 型ガードでエラーを正確に識別する

ユニオン型で複数のエラーを管理する場合、型ガードを使用してエラーを正確に識別し、適切な処理を行います。型ガードはエラー処理の誤りを防ぎ、意図しないエラーパターンの処理ミスを防ぐために重要です。

例えば、次のようにカスタム型ガードを利用してエラーを安全に処理します。

function isFileError(error: any): error is FileError {
  return error instanceof FileError;
}

function processError(error: FileError | NetworkError) {
  if (isFileError(error)) {
    console.log(`ファイルエラー: ${error.filePath}, コード: ${error.code}`);
  } else {
    console.log(`ネットワークエラー: ステータス ${error.statusCode}`);
  }
}

型ガードを使用することで、コードの安全性が高まり、バグの原因となる型の不整合を回避できます。

4. ログとエラーメッセージを適切に管理する

エラーハンドリング時にログを正確に出力することは、後のデバッグや問題解決に役立ちます。エラーメッセージをログに記録する際には、エラーメッセージに加えて、発生時の状況や入力データも保存しておくとよいでしょう。これにより、再現性のあるエラーに対して迅速に対応できます。

function logError(error: CustomError): void {
  console.error(`[ERROR] ${error.name}: ${error.message}`);
  if (error instanceof FileError) {
    console.error(`ファイルパス: ${error.filePath}, コード: ${error.code}`);
  } else if (error instanceof NetworkError) {
    console.error(`ステータスコード: ${error.statusCode}`);
  }
}

5. 再スローによるエラーチェーンの管理

例外を処理した後でも、場合によってはエラーを再スローする必要があります。再スローを行うことで、より上位の処理層でエラーを一貫して取り扱い、全体のエラーハンドリングポリシーに従うことが可能になります。

function processData() {
  try {
    performOperation();
  } catch (error) {
    if (error instanceof FileError) {
      console.log("ファイルエラー処理中...");
      throw error; // 再スロー
    } else {
      handleCustomError(error); // 他のエラーは処理
    }
  }
}

再スローを活用することで、エラーチェーンを管理し、処理の流れを乱さずにエラーを処理できます。

6. ユニットテストで例外処理をテストする

例外処理も含めたコードの動作を確実にするために、ユニットテストを行うことが不可欠です。特にユニオン型を使った複雑なエラーハンドリングは、テストによってしっかりと検証しましょう。

test("ファイルエラーが正しく処理されること", () => {
  const error = new FileError("ファイルが見つかりません", "/path/to/file", 404);
  const result = handleCustomError(error);
  expect(result).toBe("ファイルエラー: /path/to/file");
});

ユニットテストにより、想定通りにエラーが処理されるかどうかを確認することができ、実際の運用での信頼性が向上します。

これらのベストプラクティスを守ることで、TypeScriptでの例外処理がより堅牢で効率的になり、ユニオン型を活用したエラーハンドリングを最大限に活用できます。

パターンマッチングによる例外処理の最適化

TypeScriptでは、複数のエラータイプをユニオン型で扱う場合に、型ガードを使用して例外処理を行うのが一般的ですが、さらに効率的な処理方法として「パターンマッチング」を活用する方法もあります。パターンマッチングは、複数の型をまとめて一元的に処理する際に役立ち、コードのシンプルさと可読性を向上させる手法です。

パターンマッチングの基本

TypeScriptには直接的なパターンマッチング構文はありませんが、switch文や条件分岐を使ってそれに似た処理を実装できます。これにより、複数のエラータイプを簡潔に処理することが可能です。

次の例は、ユニオン型のFileErrorとNetworkErrorをパターンマッチングのように処理する方法です。

type CustomError = FileError | NetworkError;

function handleErrorWithPatternMatching(error: CustomError) {
  switch (error.type) {
    case "FileError":
      console.log(`ファイルエラー: ${error.message} (コード: ${error.code})`);
      break;
    case "NetworkError":
      console.log(`ネットワークエラー: ${error.error} (ステータス: ${error.statusCode})`);
      break;
    default:
      console.log("未知のエラーが発生しました");
  }
}

この例では、switch文を使用してエラーの種類に応じた処理を行っています。switch文は複数のケースに対して迅速に対応できるため、複雑なエラーハンドリングを簡潔に書くことができます。

パターンマッチングによる最適化の利点

パターンマッチングを用いると、次のような利点があります。

  • 可読性の向上：条件分岐をシンプルに整理でき、各エラーパターンごとの処理が明確になります。
  • メンテナンス性の向上：後から新しいエラーパターンを追加する際も、switch文にケースを追加するだけで対応でき、コード全体が一貫性を持ちやすくなります。
  • パフォーマンスの向上：switch文は複数の条件を効率的に処理するため、大規模なプロジェクトで多くのエラー処理を行う際にもパフォーマンスの最適化に寄与します。

複雑なパターンの処理

ユニオン型に含まれるエラーの数が増えると、switch文や条件分岐が複雑になることがあります。その場合、エラーパターンごとの共通処理を関数に分けて、コードを整理することが効果的です。例えば、次のように各パターンの処理を関数に分離することができます。

function handleFileError(error: FileError) {
  console.log(`ファイルエラー: ${error.message} (コード: ${error.code})`);
}

function handleNetworkError(error: NetworkError) {
  console.log(`ネットワークエラー: ${error.error} (ステータス: ${error.statusCode})`);
}

function handleErrorWithFunctions(error: CustomError) {
  switch (error.type) {
    case "FileError":
      handleFileError(error);
      break;
    case "NetworkError":
      handleNetworkError(error);
      break;
    default:
      console.log("未知のエラーが発生しました");
  }
}

このようにエラーごとの処理を関数に分割することで、処理内容が明確になり、複雑さを軽減できます。さらに、新しいエラーパターンが追加された際の拡張も容易になります。

パターンマッチングを使った再スローの活用

パターンマッチングを使ってエラーハンドリングを行う場合、一部のエラーは処理後に再スローすることが必要な場合があります。再スローを効果的に使うことで、エラーの連鎖を適切に処理することができます。

function handleErrorWithReThrow(error: CustomError) {
  switch (error.type) {
    case "FileError":
      console.log(`ファイルエラー: ${error.message} (コード: ${error.code})`);
      break;
    case "NetworkError":
      console.log(`ネットワークエラー: ${error.error} (ステータス: ${error.statusCode})`);
      throw error; // 再スロー
    default:
      throw new Error("未知のエラーが発生しました");
  }
}

try {
  const error = throwError();  // エラーを発生させる関数
  handleErrorWithReThrow(error);
} catch (error) {
  console.log("エラーを再度キャッチしました");
}

この例では、NetworkErrorが発生した場合にエラーを再スローし、さらに上位の処理で再度キャッチしています。この方法により、エラーの階層構造を維持しつつ、特定の処理で例外を再処理できます。

まとめ

パターンマッチングを活用したユニオン型の例外処理は、複雑なエラー処理をシンプルに整理し、メンテナンス性やパフォーマンスを向上させる強力な手法です。switch文や条件分岐を使ってエラーパターンごとに処理を分け、関数分離や再スローを組み合わせることで、より洗練されたエラーハンドリングが可能になります。パターンマッチングを使いこなすことで、例外処理の効率化と可読性の向上を実現しましょう。

応用: 大規模プロジェクトでのユニオン型と例外処理

大規模なTypeScriptプロジェクトでは、エラーハンドリングの複雑さが増し、より高度で効率的な方法が求められます。特に複数のモジュールや外部APIを扱う場合、発生するエラーパターンも多岐にわたり、それぞれに適した例外処理が必要です。ユニオン型を使うことで、こうしたエラーの統一的な管理と、プロジェクト全体での一貫性を確保することが可能です。この章では、ユニオン型を使った大規模プロジェクトにおける例外処理の応用例を紹介します。

ユニオン型でエラーを一元管理する

大規模プロジェクトでは、複数のモジュールやサービスから発生するエラーを一元管理することが求められます。ユニオン型を使えば、さまざまなエラータイプを統一して扱うことができ、各モジュールが異なるエラーパターンを持っていても、共通のインターフェースで処理できます。

例えば、複数のAPIを統合するプロジェクトにおいて、以下のように異なるエラーパターンを定義し、それをユニオン型でまとめることができます。

type ApiError = { type: "ApiError"; status: number; message: string };
type DatabaseError = { type: "DatabaseError"; query: string; message: string };
type ValidationError = { type: "ValidationError"; field: string; message: string };

type ProjectError = ApiError | DatabaseError | ValidationError;

このように、ApiError、DatabaseError、ValidationErrorといった異なるエラーをProjectErrorというユニオン型にまとめることで、プロジェクト全体で共通のエラーハンドリングが実現できます。

エラーハンドリングの中央集約化

大規模プロジェクトでは、エラーハンドリングを各モジュールでバラバラに行うのではなく、中央集約的なエラーハンドリングシステムを構築するのが一般的です。これにより、エラーログの一元管理や、特定のエラーパターンに対する共通の対応がしやすくなります。

以下は、エラー処理を一箇所に集約する例です。

function handleProjectError(error: ProjectError) {
  switch (error.type) {
    case "ApiError":
      console.error(`APIエラー: ステータス ${error.status}, メッセージ: ${error.message}`);
      break;
    case "DatabaseError":
      console.error(`データベースエラー: クエリ ${error.query}, メッセージ: ${error.message}`);
      break;
    case "ValidationError":
      console.error(`バリデーションエラー: フィールド ${error.field}, メッセージ: ${error.message}`);
      break;
    default:
      console.error("未知のエラーが発生しました");
  }
}

このように、ユニオン型を使って中央集約的なエラーハンドリングシステムを構築することで、複数のモジュールで発生する異なるエラーを効率的に管理し、一貫したエラーログの記録や通知が可能になります。

外部ライブラリやAPIとの連携時の例外処理

大規模プロジェクトでは、外部APIやサードパーティのライブラリとの連携が頻繁に行われます。この際に発生するエラーも、プロジェクト全体で統一的に扱う必要があります。外部APIのエラーを自作のエラー型に変換してユニオン型に組み込み、内部で一貫して処理することができます。

例えば、外部APIから返ってくるエラーをApiErrorとして定義し、それをプロジェクト内のエラーハンドリングシステムに統合します。

async function fetchFromApi(): Promise<void> {
  try {
    const response = await fetch("https://api.example.com/data");
    if (!response.ok) {
      throw { type: "ApiError", status: response.status, message: "APIリクエストに失敗しました" };
    }
  } catch (error) {
    handleProjectError(error as ProjectError);
  }
}

ここでは、外部APIからのエラーをApiError型としてキャッチし、中央のエラーハンドリングシステムで処理しています。このように、外部リソースからのエラーもプロジェクト内の一元的なシステムで管理できます。

新しいエラータイプへの拡張性

大規模プロジェクトでは、後から新しいエラータイプが追加される可能性があります。ユニオン型を使ったエラーハンドリングは、こうした拡張に対しても柔軟です。新しいエラータイプを追加する際には、ユニオン型に新しい型を追加し、中央のエラーハンドリング関数に対応する処理を追加するだけで済みます。

例えば、新たにAuthenticationErrorを追加する場合、次のように簡単に拡張できます。

type AuthenticationError = { type: "AuthenticationError"; message: string };

type ProjectError = ApiError | DatabaseError | ValidationError | AuthenticationError;

function handleProjectError(error: ProjectError) {
  switch (error.type) {
    case "ApiError":
      console.error(`APIエラー: ステータス ${error.status}, メッセージ: ${error.message}`);
      break;
    case "DatabaseError":
      console.error(`データベースエラー: クエリ ${error.query}, メッセージ: ${error.message}`);
      break;
    case "ValidationError":
      console.error(`バリデーションエラー: フィールド ${error.field}, メッセージ: ${error.message}`);
      break;
    case "AuthenticationError":
      console.error(`認証エラー: ${error.message}`);
      break;
    default:
      console.error("未知のエラーが発生しました");
  }
}

このように、プロジェクトの進行に伴い新しいエラーが発生した場合でも、ユニオン型を使ったエラーハンドリングは簡単に拡張できます。

まとめ

大規模なTypeScriptプロジェクトでは、ユニオン型を使った例外処理が非常に効果的です。複数のエラーパターンを統一的に扱うことで、コードの一貫性や可読性を保ちながら、エラーを効率的に処理できます。また、エラーハンドリングを中央集約化し、外部APIやサードパーティライブラリとの連携時にも適切な処理ができるため、プロジェクト全体のエラーハンドリングがスムーズになります。ユニオン型の柔軟性を活かし、スケーラブルなエラーハンドリングシステムを構築することが、大規模プロジェクトにおける成功の鍵となります。

演習問題: ユニオン型と例外処理の実践練習

ここでは、ユニオン型を活用したTypeScriptの例外処理を実践的に学ぶための演習問題を用意しました。実際のコードを書きながら、ユニオン型による複数のエラーパターンの処理方法を習得できます。これらの問題を解くことで、より深くTypeScriptのユニオン型を使ったエラーハンドリングに慣れることができるでしょう。

問題1: カスタムエラー型の定義と処理

次のシナリオに従って、カスタムエラー型を作成し、それをユニオン型で処理する関数を実装してください。

  • DatabaseError: データベースクエリが失敗したときに発生するエラーで、queryとmessageのプロパティを持つ。
  • ApiError: API呼び出しが失敗したときに発生するエラーで、statusとmessageのプロパティを持つ。
  • ValidationError: ユーザー入力が無効な場合に発生するエラーで、fieldとmessageのプロパティを持つ。

これらのエラー型を作成し、ユニオン型AppErrorでまとめて処理する関数handleAppErrorを実装してください。

type DatabaseError = { type: "DatabaseError"; query: string; message: string };
type ApiError = { type: "ApiError"; status: number; message: string };
type ValidationError = { type: "ValidationError"; field: string; message: string };

type AppError = DatabaseError | ApiError | ValidationError;

function handleAppError(error: AppError) {
  // ここに処理を実装
}

ヒント: switch文または型ガードを使用して、エラーパターンに応じた処理を実装してください。

問題2: エラーを発生させて処理する

次に、AppError型を返す関数performOperationを実装し、それに基づいてエラーを処理してください。この関数は、ランダムにDatabaseError、ApiError、またはValidationErrorを返すようにします。

function performOperation(): AppError {
  // ランダムにエラーを返す
  const errors = [
    { type: "DatabaseError", query: "SELECT * FROM users", message: "データベースクエリに失敗しました" },
    { type: "ApiError", status: 500, message: "サーバーエラーが発生しました" },
    { type: "ValidationError", field: "email", message: "無効なメールアドレスです" }
  ];
  return errors[Math.floor(Math.random() * errors.length)];
}

上記のperformOperation関数を呼び出し、その結果をhandleAppError関数で処理するコードを実装してください。

const error = performOperation();
handleAppError(error);

問題3: 新しいエラー型の追加

今度は、新しいエラー型AuthenticationErrorを追加して、ユーザー認証が失敗した際のエラーを処理するように関数を拡張してください。

type AuthenticationError = { type: "AuthenticationError"; message: string };

type AppError = DatabaseError | ApiError | ValidationError | AuthenticationError;

handleAppError関数を修正し、AuthenticationErrorも処理できるようにしてください。

function handleAppError(error: AppError) {
  // ここにAuthenticationErrorの処理を追加
}

問題4: 実際に例外をスローして処理する

次に、エラーを実際にスローし、それをtry-catchブロックでキャッチして処理するシナリオを実装してください。エラーがスローされた場合は、handleAppErrorで適切に処理します。

function riskyOperation() {
  const error = performOperation();
  throw error;  // ランダムにエラーをスロー
}

try {
  riskyOperation();
} catch (error) {
  handleAppError(error as AppError);  // キャッチしたエラーを処理
}

問題5: エラーハンドリングのユニットテスト

最後に、これまでに実装したエラーハンドリングの機能が期待通りに動作するかどうかを確認するためのユニットテストを作成してください。jestや他のテストフレームワークを使って、各エラータイプに対して正しい処理が行われているかをテストします。

test("DatabaseErrorが正しく処理されること", () => {
  const error: DatabaseError = { type: "DatabaseError", query: "SELECT * FROM users", message: "データベースクエリに失敗しました" };
  handleAppError(error);
  // 期待される処理が行われたことを確認
});

まとめ

これらの演習を通じて、TypeScriptのユニオン型を活用したエラーハンドリングの実装力を高めることができます。カスタムエラー型の設計や処理、実際のスローとキャッチの処理、新しいエラーパターンの追加、さらにはユニットテストを通じて、堅牢なエラーハンドリングの実践力を養いましょう。

まとめ

本記事では、TypeScriptでユニオン型を使った例外処理の方法について解説しました。ユニオン型を活用することで、複数の異なるエラーパターンを型安全に管理し、一貫性のあるエラーハンドリングが可能になります。パターンマッチングや型ガードを使った柔軟な処理、カスタムエラー型の設計と拡張性、さらに大規模プロジェクトでの応用方法について学びました。これらの知識を活かすことで、より堅牢でメンテナンス性の高いコードを書くことができるでしょう。

TypeScript
プログラミング 例外処理 TypeScript ユニオン型

コメント

コメントする

目次