MENU
  1. ホーム
  2. TypeScript
  3. TypeScriptでユニオン型を使った型安全なエラーハンドリングを解説

TypeScriptでユニオン型を使った型安全なエラーハンドリングを解説

TypeScript

TypeScriptは、JavaScriptのスーパーセットとして広く利用されており、その特徴の一つに「型安全性」が挙げられます。型安全性とは、コードの実行前に型エラーを検出できる仕組みであり、バグの発生を防ぎ、開発者がより信頼性の高いコードを書けるようにするものです。本記事では、この型安全性を維持しつつ、エラーハンドリングを行うための方法として「ユニオン型」と「null/undefined」を組み合わせた実装について解説します。特に、APIのエラーハンドリングや関数の戻り値において、ユニオン型をどのように使いこなせば、TypeScriptならではの強力な型システムを活用した安全なコードを実現できるかに焦点を当てます。

目次

型安全なエラーハンドリングとは？

型安全なエラーハンドリングとは、プログラム内で発生するエラーを事前に検知し、予期しない動作を防ぐために、適切に型の情報を使ってエラーハンドリングを行う方法です。TypeScriptでは、型を明示することでエラーの発生が予測可能になり、実行時に起こり得る問題をコンパイル時に検知することができます。型安全なエラーハンドリングを実装することで、開発者は意図しないエラーを未然に防ぎ、予測可能なエラー処理が可能になります。

JavaScriptのように動的型付け言語では、エラーが実行時まで検出されないことが多く、これが予期せぬバグにつながりますが、TypeScriptではユニオン型や型ガードを活用することで、エラーの処理をより安全かつ明確にすることができます。

TypeScriptにおけるユニオン型の基本

TypeScriptのユニオン型は、変数が複数の型のいずれかを持つことができる仕組みです。これは、ある変数が特定の型に制約されず、複数の型を持つ可能性がある場合に非常に役立ちます。例えば、関数の戻り値が数値または文字列のいずれかになることを示す場合、ユニオン型を使うことで柔軟に対応できます。

ユニオン型の基本的な書き方は、複数の型を「|」で区切るだけです。例えば、以下のように定義できます。

let result: number | string;
result = 42; // OK
result = "Error"; // OK

この例では、resultは数値型か文字列型のどちらかを取ることができ、型安全に動作します。これにより、関数の戻り値が成功した場合は数値、失敗した場合はエラーメッセージ（文字列）というようなケースに対応できます。ユニオン型を使用することで、コードの柔軟性を保ちつつ、型チェックを行い、安全なエラーハンドリングが可能となります。

nullやundefinedとユニオン型の組み合わせ

TypeScriptでは、nullやundefinedもユニオン型と組み合わせることで、明示的に「値が存在しない」状態を型として表現することができます。これにより、値が存在しない可能性を予め考慮し、安全なコードを記述することが可能です。

たとえば、ある関数がエラーを返す場合や、成功した際には値を返す場合、nullやundefinedをユニオン型として使用して、結果の有無を表現できます。

function getData(id: number): string | null {
    if (id === 0) {
        return null; // データが見つからない場合
    } else {
        return "データが取得されました"; // 成功時
    }
}

let result = getData(0);
if (result === null) {
    console.log("データが見つかりませんでした");
} else {
    console.log(result);
}

この例では、getData関数が文字列を返すか、データが見つからない場合はnullを返すことを示しています。このようにユニオン型を使うことで、nullやundefinedの可能性を考慮した安全なエラーハンドリングが実現します。

また、undefinedも同様にユニオン型と組み合わせて使用することができます。例えば、APIのレスポンスがundefinedになる可能性を考慮する場合、次のように書けます。

let response: string | undefined;
response = fetchApiData(); // 仮想的なAPI呼び出し
if (response === undefined) {
    console.error("APIからデータが取得できませんでした");
} else {
    console.log("取得データ: " + response);
}

このように、nullやundefinedをユニオン型として明示的に扱うことで、潜在的なエラーを未然に防ぎ、コードの安全性を高めることができます。

エラーハンドリングにユニオン型を利用する利点

ユニオン型をエラーハンドリングに利用することで、多くの利点が得られます。特に、TypeScriptの型システムを活用することで、エラーの発生状況を型として明示的に表現でき、コードの安全性や可読性が向上します。

型安全性の向上

ユニオン型を使用することで、成功時のデータ型とエラー時のデータ型を1つの型として扱うことができます。これにより、エラーハンドリングを型レベルで強制することができ、意図しないエラーをコンパイル時に検出できます。例えば、エラーが返る可能性がある関数を呼び出す際に、そのエラーの型を定義しておくことで、呼び出し側がエラー処理を確実に実装するように促せます。

type Success = { data: string };
type Failure = { error: string };
type Result = Success | Failure;

function fetchData(): Result {
    // 仮にデータが取得できなかった場合の処理
    return Math.random() > 0.5
        ? { data: "取得成功" }
        : { error: "データ取得失敗" };
}

let result = fetchData();
if ("error" in result) {
    console.error(result.error); // エラー処理
} else {
    console.log(result.data); // 成功時の処理
}

この例では、Result型をユニオン型として、成功時とエラー時の両方の結果を表現しています。結果をチェックする際には、型に応じた処理が必須となり、エラーチェックが確実に行われます。

コードの可読性と保守性の向上

ユニオン型を使うことで、エラー処理が一目でわかりやすくなります。エラーハンドリングが型として明示されるため、開発者が後からコードを見返したときにも、どのようなエラーパターンが考慮されているのかが理解しやすくなります。さらに、新しいエラーパターンが追加された際も、型を更新するだけでエラーハンドリングが強化されるため、保守性が向上します。

例外処理よりも軽量なエラーハンドリング

JavaScriptやTypeScriptでは、try-catchによる例外処理もありますが、例外は主に異常な状態を示すために使用されます。ユニオン型によるエラーハンドリングは、例外ほど重くなく、通常の処理フロー内でエラーを扱うことができるため、軽量で柔軟です。これにより、パフォーマンスへの影響を抑えつつ、安全なエラーハンドリングが可能になります。

このように、ユニオン型を活用することで、エラー処理が型レベルで明確化され、開発者は安全かつ効率的なエラーハンドリングを実現できるのです。

実際のコード例：シンプルなエラーハンドリング

ユニオン型を活用したエラーハンドリングを、具体的なTypeScriptのコードで見てみましょう。ここでは、シンプルなAPI呼び出しのシミュレーションを例に、エラーが発生する可能性がある場合の処理を行います。

次のコードでは、成功と失敗のケースをそれぞれユニオン型で表現し、適切なエラーハンドリングを実装しています。

type SuccessResponse = { status: "success"; data: string };
type ErrorResponse = { status: "error"; message: string };
type APIResponse = SuccessResponse | ErrorResponse;

function fetchDataFromAPI(): APIResponse {
    // 成功またはエラーをランダムに返すシミュレーション
    if (Math.random() > 0.5) {
        return { status: "success", data: "APIデータ取得成功" };
    } else {
        return { status: "error", message: "APIエラーが発生しました" };
    }
}

function handleAPIResponse(response: APIResponse) {
    if (response.status === "success") {
        console.log("データ: " + response.data);
    } else {
        console.error("エラー: " + response.message);
    }
}

// 実際の関数呼び出し
const response = fetchDataFromAPI();
handleAPIResponse(response);

このコードでは、fetchDataFromAPI関数が、成功時にはSuccessResponse型のデータを、エラー時にはErrorResponse型のデータを返すように定義されています。この2つの型をAPIResponseというユニオン型でまとめることにより、エラー処理を強制し、どちらのケースでも適切な処理が行われるようになっています。

実行結果の処理

handleAPIResponse関数では、responseのstatusフィールドをチェックすることで、成功かエラーかを判定しています。成功時には取得したデータをコンソールに出力し、エラー時にはエラーメッセージを出力します。

このように、ユニオン型を使用することで、返される値が成功か失敗かを明示的に扱うことができ、TypeScriptの型システムによって安全なエラーハンドリングが可能になります。

ユニオン型によるコードのメリット

  • 安全性: 型システムによって、返り値が必ず成功かエラーのいずれかであることが保証されます。
  • 明確なエラーハンドリング: どの部分でエラーチェックを行うべきかが明確になり、エラーの見逃しが防げます。
  • 可読性: 成功とエラーがそれぞれの型に明示的に分かれているため、コードを読む際にどのような処理が必要かがすぐに分かります。

このシンプルなエラーハンドリングの例は、TypeScriptを使って実装する際に役立つ基本的なパターンとなります。

エラーハンドリングでのnull/undefinedチェック方法

TypeScriptでは、エラーハンドリングにおいてnullやundefinedが返される可能性を考慮することが重要です。nullやundefinedの値を適切にチェックすることで、エラーが発生した場合の処理を安全かつ効果的に行えます。ここでは、nullやundefinedを安全に扱うためのチェック方法と実装パターンを紹介します。

基本的なnull/undefinedチェック

nullやundefinedが返される可能性がある場合、明示的にその値をチェックするのが一般的です。TypeScriptでは、if文を使って値の存在をチェックする方法がよく使われます。

function getData(): string | null {
    const success = Math.random() > 0.5;
    return success ? "データ取得成功" : null;
}

let result = getData();

if (result === null) {
    console.error("データが存在しません");
} else {
    console.log("取得データ: " + result);
}

この例では、getData関数がデータを返すか、nullを返す場合があります。resultにnullが入っているかどうかをif文でチェックし、nullであればエラーメッセージを表示し、nullでなければデータを処理しています。

オプショナルチェーンを使った簡略化

TypeScriptの「オプショナルチェーン演算子」（?.）を使用すると、nullやundefinedのチェックを簡単に行うことができます。この演算子は、オブジェクトのプロパティやメソッド呼び出し時に、nullまたはundefinedでない場合にのみ処理を続行します。

function getUser(): { name?: string } {
    return Math.random() > 0.5 ? { name: "ユーザー名" } : {};
}

const user = getUser();
console.log(user?.name ?? "名前が設定されていません");

この例では、userオブジェクトがnameプロパティを持たない場合でもエラーを回避し、nullやundefinedであればデフォルトのメッセージを表示します。オプショナルチェーンを使うことで、コードがよりシンプルになり、nullやundefinedを意識した安全なエラーハンドリングが実現できます。

非nullアサーション演算子

TypeScriptには、nullやundefinedでないことを明示的に宣言するための「非nullアサーション演算子」（!）があります。この演算子を使用すると、コンパイラに対して「この値は絶対にnullやundefinedではない」と伝えることができます。

let element: HTMLElement | null = document.getElementById("myElement");

element!.style.color = "red";

この場合、elementがnullである可能性はコンパイラによって検知されません。しかし、非nullアサーション演算子は慎重に使うべきです。nullでないことを確信している場合にのみ使用するようにし、過信すると実行時エラーの原因になることがあります。

型ガードによるnullチェック

より堅牢な実装には、型ガードを使ったチェックも有効です。型ガードを利用すると、値が特定の型であることを保証し、その型に基づいて処理を行えます。

function isNotNull<T>(value: T | null): value is T {
    return value !== null;
}

let data: string | null = getData();

if (isNotNull(data)) {
    console.log("データ: " + data); // dataは確実にstring型
} else {
    console.error("データが存在しません");
}

このように、型ガードを使うことで、nullチェックを行いつつ、TypeScriptの型システムに沿った安全なコードを記述できます。

まとめ

nullやundefinedが関数の戻り値やオブジェクトのプロパティとして返ってくる場合に備え、明示的なチェックやオプショナルチェーン、非nullアサーション、型ガードなどを適切に使うことが重要です。これにより、潜在的なエラーを未然に防ぎ、型安全なエラーハンドリングが実現できます。

例外処理との比較：どちらを選ぶべきか？

TypeScriptでエラーハンドリングを行う際、ユニオン型を使った方法とtry-catchを用いる例外処理の2つの選択肢があります。それぞれに利点と適用すべき状況があるため、どちらを選ぶべきかを理解することが重要です。ここでは、ユニオン型と例外処理の違いを比較し、それぞれのメリットを解説します。

ユニオン型を使ったエラーハンドリング

ユニオン型を使ったエラーハンドリングは、エラーが予測可能であり、通常の制御フローの一部としてエラーを処理したい場合に適しています。この方法では、関数が成功と失敗の結果をユニオン型で表し、呼び出し元がその結果をチェックして処理します。

メリット:

  • 型安全性: TypeScriptの型システムに統合されているため、エラー処理が型レベルで強制されます。エラー処理が見逃されるリスクが少なくなります。
  • 予測可能な制御フロー: エラーが通常の関数の戻り値として返されるため、コードのフローが明確であり、例外が発生する場所を意識する必要がありません。
  • 軽量な処理: 例外処理に比べてパフォーマンスへの影響が少なく、エラーの頻度が高い場合でもオーバーヘッドが小さくなります。

デメリット:

  • 成功と失敗の処理が煩雑になる: 成功とエラーのケースを常に明示的にチェックしなければならないため、コードが長くなることがあります。
type Result = { success: true, data: string } | { success: false, error: string };

function fetchData(): Result {
    return Math.random() > 0.5
        ? { success: true, data: "取得成功" }
        : { success: false, error: "エラーが発生しました" };
}

const result = fetchData();
if (result.success) {
    console.log(result.data);
} else {
    console.error(result.error);
}

この例では、成功とエラーの両方が型レベルで定義され、エラーが通常の制御フローの中で処理されています。

例外処理 (`try-catch`)

try-catchによる例外処理は、予測不可能なエラーや、エラーが関数の深い階層で発生する場合に適しています。例外は、プログラムが通常の処理フローを中断し、異常な状態に対処するために使われます。

メリット:

  • エラーフローの分離: 成功時の処理とエラーハンドリングが明確に分離されるため、エラーフローがプログラムの主な処理とは独立します。
  • 深い階層でのエラー対応: 関数の深い階層で発生したエラーも上位のtry-catchブロックでキャッチできるため、複雑なアプリケーションでもエラーハンドリングが一元化されやすいです。

デメリット:

  • 例外処理のオーバーヘッド: 例外はパフォーマンスに影響を与えるため、頻繁にエラーが発生する状況では処理が重くなる可能性があります。
  • 予測不可能な制御フロー: 例外が発生すると通常の制御フローが中断され、プログラムが意図した通りに進行しない可能性があります。
function fetchDataWithError(): string {
    if (Math.random() > 0.5) {
        return "データ取得成功";
    } else {
        throw new Error("データ取得エラー");
    }
}

try {
    const data = fetchDataWithError();
    console.log(data);
} catch (error) {
    console.error(error.message);
}

この例では、例外が発生した場合にtry-catchで捕捉され、エラーメッセージが表示されます。エラー処理が成功時の処理から分離されているため、コードがより簡潔になる場合もあります。

どちらを選ぶべきか？

  • ユニオン型を選ぶべき場合: エラーが通常の処理フローの一部であり、エラーが予測できる場合や、型安全性を高めたい場合に適しています。特に、API呼び出しやフォームのバリデーションなど、エラー処理が頻繁に必要なケースではユニオン型が有効です。
  • 例外処理を選ぶべき場合: 予測不可能なエラーや異常な事態を扱う場合、または深い階層で発生したエラーをまとめて処理したい場合に適しています。I/O処理や非同期処理での例外対応にも向いています。

どちらの方法もエラーハンドリングにおいて有効ですが、適切な状況で適切な手法を選ぶことが、堅牢で安全なプログラムの実現につながります。

実用的な応用例：API呼び出しのエラーハンドリング

API呼び出しにおけるエラーハンドリングは、特に外部サービスと通信する際に非常に重要です。TypeScriptのユニオン型を使うことで、APIのレスポンスが成功か失敗かを型として表現し、型安全にエラーハンドリングを行うことができます。ここでは、実際のAPI呼び出しを想定した例を見ながら、ユニオン型を利用した型安全なエラーハンドリングを実装します。

APIレスポンスをユニオン型で定義

まず、APIからのレスポンスが成功時とエラー時にどのようなデータを返すかを型で定義します。成功時にはデータが、エラー時にはエラーメッセージが返される場合を考えます。

type APIResponseSuccess = {
    status: "success";
    data: { id: number; name: string };
};

type APIResponseError = {
    status: "error";
    message: string;
};

type APIResponse = APIResponseSuccess | APIResponseError;

このAPIResponse型は、成功時にはstatusが"success"であり、データを含むオブジェクトを返します。一方、エラー時にはstatusが"error"で、エラーメッセージを含むオブジェクトが返されるように定義されています。

API呼び出し関数の実装

次に、この型を使って、実際のAPI呼び出し関数を実装します。この関数は外部APIにリクエストを送り、レスポンスを受け取って、結果をユニオン型として返します。

async function fetchUserData(userId: number): Promise<APIResponse> {
    try {
        const response = await fetch(`https://api.example.com/users/${userId}`);
        if (!response.ok) {
            return { status: "error", message: "データ取得に失敗しました" };
        }
        const data = await response.json();
        return { status: "success", data };
    } catch (error) {
        return { status: "error", message: "ネットワークエラーが発生しました" };
    }
}

この関数では、fetchを使ってAPIにリクエストを送信しています。APIリクエストが成功した場合は、レスポンスのデータをAPIResponseSuccess型として返し、失敗した場合（例えば、ネットワークエラーやレスポンスステータスが200以外の場合）にはAPIResponseError型を返しています。

APIレスポンスのハンドリング

次に、API呼び出しの結果を処理するコードを実装します。レスポンスが成功かエラーかをstatusフィールドで判定し、それぞれのケースに応じた処理を行います。

async function handleAPIResponse(userId: number) {
    const result = await fetchUserData(userId);

    if (result.status === "success") {
        console.log("ユーザー情報:", result.data);
    } else {
        console.error("エラー:", result.message);
    }
}

// 実際の呼び出し
handleAPIResponse(1);

このコードでは、fetchUserData関数の結果を受け取り、statusフィールドを使って、成功時とエラー時の処理を分岐させています。成功時にはユーザーの情報をコンソールに出力し、エラー時にはエラーメッセージを表示します。

非同期処理と型安全なエラーハンドリング

API呼び出しは非同期処理で行われることが多く、async/await構文を使うことで、エラーハンドリングもシンプルに記述できます。ユニオン型を使うことで、APIレスポンスが成功か失敗かを型として表現でき、エラー処理が予測可能になります。

非同期処理の際、例外が発生する可能性がありますが、ユニオン型を使って結果を明示的にエラーと成功に分けて扱うことで、例外処理の必要性が減少し、コードの可読性が向上します。また、例外処理をtry-catchで行いつつ、レスポンスの状態をユニオン型で表すことにより、柔軟で安全なエラーハンドリングが実現します。

実践的な応用

この手法は、API呼び出しだけでなく、ファイルの読み書き、データベースクエリ、ユーザー入力のバリデーションなど、エラーが発生する可能性のあるあらゆる場面で応用可能です。ユニオン型を活用することで、エラーハンドリングのパターンを一貫して実装でき、コードの保守性が向上します。

TypeScriptの強力な型システムを最大限に活用することで、予期しないエラーの発生を防ぎ、安全で信頼性の高いコードを書くことが可能になります。

TypeScriptで型安全なエラーハンドリングを導入する際の注意点

ユニオン型やnull/undefinedを用いた型安全なエラーハンドリングは、TypeScriptの強力な型システムを活用する優れた手法です。しかし、実装に際してはいくつかの注意点があります。これらのポイントに気をつけることで、より安全で堅牢なコードを書くことができ、エラーハンドリングを効果的に行うことができます。

1. 型が複雑になりすぎないように注意する

ユニオン型を用いたエラーハンドリングは柔軟ですが、複雑なユニオン型を多用すると、コードが読みにくくなり、保守が難しくなる可能性があります。特に複数のエラーパターンを扱う場合、ユニオン型が膨大になりがちです。

例えば、以下のように複数のエラー型を定義すると、エラーハンドリングが煩雑になる可能性があります。

type FileError = { status: "file_error"; message: string };
type NetworkError = { status: "network_error"; message: string };
type ValidationError = { status: "validation_error"; message: string };
type Result = FileError | NetworkError | ValidationError | { status: "success"; data: string };

このような場合、エラー型を一つにまとめるか、共通のエラーフォーマットを定義することで、コードをシンプルに保つことができます。

type ErrorResponse = { status: "error"; type: "file" | "network" | "validation"; message: string };
type SuccessResponse = { status: "success"; data: string };
type APIResponse = SuccessResponse | ErrorResponse;

2. 必ずエラーハンドリングを行うこと

ユニオン型を使用していても、エラーハンドリングが適切に実装されていないと、エラーが見逃されるリスクがあります。TypeScriptの型システムは強力ですが、実行時にエラーが発生する可能性は常に残っています。

例えば、以下のコードでは、エラーパターンが正しく処理されていない可能性があります。

const result = fetchData();
if (result.status === "success") {
    console.log(result.data);
}
// エラーパターンの処理がない

エラーが発生した際に何も処理しない場合、意図しない動作が起こる可能性があるため、必ず全てのケースを明示的に処理する必要があります。

if (result.status === "success") {
    console.log(result.data);
} else {
    console.error("エラー:", result.message);
}

3. 非同期処理での例外処理との併用に注意

API呼び出しやファイル操作など、非同期処理における例外処理とユニオン型のエラーハンドリングは、適切に使い分ける必要があります。async/await構文を使用した非同期関数では、try-catchブロックを使った例外処理が適していますが、通常のエラーハンドリングをユニオン型で扱う場合は、混在しないように注意が必要です。

async function fetchData(): Promise<APIResponse> {
    try {
        const response = await fetch('https://api.example.com/data');
        if (!response.ok) {
            return { status: "error", message: "HTTPエラー" };
        }
        const data = await response.json();
        return { status: "success", data };
    } catch (error) {
        return { status: "error", message: "ネットワークエラー" };
    }
}

try-catchで例外をキャッチしつつ、ユニオン型でエラーを返す場合、どちらのパターンでもエラーが適切に処理されるように実装する必要があります。

4. エラー型の標準化を行う

複数の関数やモジュールでエラーハンドリングを行う際、エラー型を統一しておくことが重要です。エラーの形式がバラバラだと、ハンドリングが煩雑になり、意図した動作を実装しにくくなります。プロジェクト全体で共通のエラーフォーマットを使用することで、エラー処理が一貫し、バグの発生を防ぐことができます。

type CommonError = { status: "error"; message: string };
type SuccessResponse<T> = { status: "success"; data: T };
type APIResponse<T> = SuccessResponse<T> | CommonError;

このように、共通のエラーフォーマットを定義しておけば、各モジュールでのエラーハンドリングが簡素化され、統一された処理が可能になります。

5. 過度な非nullアサーションの使用を避ける

TypeScriptの非nullアサーション（!）を多用すると、型安全性を損なう危険があります。!を使うとコンパイラに「この値は絶対にnullではない」と伝えることができますが、実行時にnullが渡される可能性がある場合、エラーが発生します。

let element: HTMLElement | null = document.getElementById("myElement");
element!.style.color = "red"; // elementがnullの場合に実行時エラー

このようなケースでは、非nullアサーションの代わりに、if文やオプショナルチェーンを使って安全に値を確認するべきです。

if (element !== null) {
    element.style.color = "red";
}

まとめ

TypeScriptで型安全なエラーハンドリングを導入する際は、コードの複雑化を避け、全てのケースを明示的にハンドリングし、例外処理と適切に組み合わせることが重要です。エラーフォーマットを標準化し、過度な非nullアサーションを避けることで、より堅牢で信頼性の高いエラーハンドリングが実現します。

演習問題：ユニオン型を使って型安全なエラーハンドリングを実装する

これまで学んできたTypeScriptのユニオン型を使った型安全なエラーハンドリングの理解を深めるために、簡単な演習問題を解いてみましょう。ここでは、ユニオン型を活用し、成功時とエラー時の結果を適切に処理する方法を実践します。

問題 1: APIレスポンスのエラーハンドリングを実装する

シナリオ

あなたは、ユーザー情報を取得するAPIを呼び出す関数を実装する必要があります。このAPIは、ユーザーIDを引数として受け取り、成功時にはユーザーの名前と年齢を含むデータを返します。一方、失敗時にはエラーメッセージが返されます。ユニオン型を使って、以下の仕様に従ってエラーハンドリングを行ってください。

仕様

  • APIレスポンスは成功時にUser型のオブジェクトを返します。
  • 失敗時には、エラーメッセージを持つオブジェクトを返します。
  • 成功時とエラー時の処理を分岐して実装します。

型定義

まずは、APIレスポンスの型定義を行います。

type User = {
    id: number;
    name: string;
    age: number;
};

type APIResponseSuccess = {
    status: "success";
    data: User;
};

type APIResponseError = {
    status: "error";
    message: string;
};

type APIResponse = APIResponseSuccess | APIResponseError;

実装

次に、ユーザー情報を取得する関数を実装してください。

async function fetchUser(userId: number): Promise<APIResponse> {
    // ここではAPI呼び出しをシミュレーションしています
    if (userId > 0) {
        return {
            status: "success",
            data: { id: userId, name: "John Doe", age: 30 }
        };
    } else {
        return {
            status: "error",
            message: "無効なユーザーIDです"
        };
    }
}

回答例

次に、ユーザー情報を取得し、結果に応じて適切に処理を行う関数を実装します。

async function handleUserResponse(userId: number) {
    const response = await fetchUser(userId);

    if (response.status === "success") {
        console.log(`ユーザー名: ${response.data.name}, 年齢: ${response.data.age}`);
    } else {
        console.error(`エラー: ${response.message}`);
    }
}

// 実際の呼び出し
handleUserResponse(1); // ユーザーが存在する場合
handleUserResponse(-1); // エラーを返す場合

問題 2: 商品検索APIのエラーハンドリング

シナリオ

次に、商品検索を行うAPIを呼び出す関数を実装します。ユーザーが入力した商品名に基づいて検索結果が返されます。成功時には、商品リストが返され、エラー時には適切なメッセージが表示されます。

型定義

以下の型定義を使って実装してください。

type Product = {
    id: number;
    name: string;
    price: number;
};

type ProductSearchSuccess = {
    status: "success";
    products: Product[];
};

type ProductSearchError = {
    status: "error";
    message: string;
};

type ProductSearchResponse = ProductSearchSuccess | ProductSearchError;

実装

商品検索APIをシミュレーションし、結果に応じたエラーハンドリングを行う関数を実装してください。

async function searchProducts(query: string): Promise<ProductSearchResponse> {
    if (query === "laptop") {
        return {
            status: "success",
            products: [
                { id: 1, name: "Laptop A", price: 1000 },
                { id: 2, name: "Laptop B", price: 1500 }
            ]
        };
    } else {
        return {
            status: "error",
            message: "商品が見つかりませんでした"
        };
    }
}

async function handleProductSearch(query: string) {
    const response = await searchProducts(query);

    if (response.status === "success") {
        response.products.forEach(product => {
            console.log(`商品名: ${product.name}, 価格: ${product.price}`);
        });
    } else {
        console.error(`エラー: ${response.message}`);
    }
}

// 実際の呼び出し
handleProductSearch("laptop"); // 成功時
handleProductSearch("phone"); // エラー時

問題のポイント

  1. ユニオン型の活用: 成功時とエラー時の結果をユニオン型で定義し、どちらのケースでも処理ができるようにすること。
  2. 型安全性の維持: TypeScriptの型チェックを活かし、エラーハンドリングが漏れなく実装されているかを確認する。
  3. 非同期処理: async/await構文を使い、非同期処理のエラーハンドリングも適切に実装すること。

まとめ

今回の演習を通じて、TypeScriptのユニオン型を活用した型安全なエラーハンドリングを実践する方法を学びました。API呼び出しなど、エラーが発生する可能性のある処理では、エラー処理が適切に行われることが、信頼性の高いアプリケーションの構築に不可欠です。

まとめ

本記事では、TypeScriptにおけるユニオン型を利用した型安全なエラーハンドリングの方法について解説しました。ユニオン型を活用することで、エラーの発生を型レベルで明示的に扱い、予測可能なエラーハンドリングが可能になります。また、nullやundefinedとの組み合わせや、例外処理との違い、非同期処理での応用についても説明しました。これにより、コードの安全性や保守性が向上し、エラー処理が確実に行われる堅牢なプログラムを実装できるようになります。

TypeScript
エラーハンドリング TypeScript 型安全 ユニオン型

コメント

コメントする

目次