【TypeScript】例外処理を完全マスター！手順とコード10選

はじめに
●TypeScriptの例外処理とは
- ○例外処理の基本概念
●例外処理の基本手法
●例外の発生方法
- ○サンプルコード4：throwを用いた例外の発生
- ○サンプルコード5：独自エラークラスの作成と使用
●例外処理の高度なテクニック
●例外処理の注意点と対処法
●例外処理のカスタマイズ方法
まとめ

はじめに

Web開発の世界では、エラーは避けて通れない存在です。

しかし、そのエラーを適切にハンドリングすることで、アプリケーションの品質やユーザー体験を高めることができます。

特に、近年人気を集めているプログラミング言語、TypeScriptでは、例外処理の概念が強力にサポートされており、それにより柔軟かつ確実にエラーハンドリングを行うことができます。

この記事では、TypeScriptを使用しての例外処理の手法を初心者から中級者向けに解説します。

10の実践的なサンプルコードを通じて、例外処理の基本から高度なテクニックまでを学び、TypeScriptにおけるエラーハンドリングの全てをマスターする手助けとなることを目指します。

TypeScriptが初めての方、あるいは例外処理の知識をさらに深めたい方の参考として、ぜひ最後までお読みください。

●TypeScriptの例外処理とは

例外とは、プログラムが期待する動作を適切に実行できない状況を指します。

これには様々な原因が考えられるため、それを捕捉し、適切に処理する必要があります。

TypeScriptにおける例外処理は、このような非期待的な動作をキャッチし、プログラムのクラッシュを防ぐための仕組みを提供します。

○例外処理の基本概念

例外処理は、主にtry-catch-finallyの三つのブロックで構成されます。

tryブロック内には、例外が発生する可能性のあるコードを記述します。

もしtryブロック内で例外が発生すれば、それはcatchブロックに渡され、エラーの詳細情報を取得・処理することができます。

最後にfinallyブロックは、エラーの有無に関わらず必ず実行される部分となります。

●例外処理の基本手法

例外処理は、プログラム中の予期しないエラーや特定の条件が発生した場合に、適切に対応するための手段として使用されます。

TypeScriptでは、JavaScriptの例外処理の手法を引き継ぎつつ、型安全性を考慮した例外処理を実装することができます。

○サンプルコード1：基本的なtry-catch構文

TypeScriptでも、最も基本的な例外処理の手法として、try-catch構文が提供されています。

その基本的な使用方法を紹介します。

// 簡単な関数を定義します。この関数は、引数として渡された値が10未満であればエラーをスローします。
function validateNumber(n: number) {
  if (n < 10) {
    throw new Error('数値は10以上である必要があります。');
  }
  return n;
}

try {
  // この関数を呼び出してみます。
  const num = validateNumber(5);
  console.log(num); 
} catch (error) {
  console.log(error.message); // エラーメッセージを表示します。
}

このコードでは、validateNumber関数内で数値が10未満であるかをチェックしています。10未満の場合、エラーをスローします。

主要な処理はtryブロック内に記述され、もしtryブロック内の処理中にエラーが発生した場合、即座にcatchブロックが実行されます。

この例では、エラーが発生するとエラーメッセージがコンソールに表示されます。

このコードを実際に実行すると、”数値は10以上である必要があります。”というメッセージが出力されることが確認できます。

try-catch構文を利用することで、エラーの発生箇所とそのハンドリング箇所を明確にし、プログラムの安定性や可読性を向上させることができます。

○サンプルコード2：catchでエラーオブジェクトを受け取る方法

例外処理において、エラー情報を詳しく知るためにはエラーオブジェクトをcatch節で受け取ることが非常に重要です。

このエラーオブジェクトは、発生した例外の具体的な情報を提供し、エラーの原因を特定しやすくする助けとなります。

TypeScriptでは、例外が発生した場合、それに関する詳細情報を持つエラーオブジェクトが自動的に生成されます。

基本的なtry-catch構文でエラーオブジェクトを受け取る方法のサンプルコードを紹介します。

try {
    // 0での割り算はエラーを引き起こす
    const result = 10 / 0;
    console.log(result);
} catch (error) {
    // エラーオブジェクトを受け取り、情報を表示
    console.log(`エラーが発生しました: ${error.message}`);
}

このコードでは、10を0で割る操作を試みています。

0での除算は数学的に不可能であるため、JavaScriptエンジンはエラーをスローします。

このエラーはtryブロック内で捕捉され、catchブロックが実行されることになります。

catch節ではエラーオブジェクトをerrorという名前で受け取っており、そのmessageプロパティを用いてエラーメッセージを表示しています。

上記のコードを実際に実行すると、次のような結果が得られることを期待します。

エラーが発生しました: Infinity is not a valid result of division by zero.（実際のエラーメッセージは実行環境やブラウザによって異なる場合があります）

エラーオブジェクトには、発生したエラーに関する多くの情報が含まれています。

最も一般的に使用されるのはmessageプロパティですが、他にもスタックトレースやエラーが発生したファイルの情報など、デバッグに役立つ情報が詰まっています。

この方法を用いると、エラーが発生した原因や状況を具体的に把握し、効果的なデバッグやエラーハンドリングを行うことが可能になります。

エラーオブジェクトの受け取り方は非常に簡単なので、初心者の方もすぐに取り入れることができるでしょう。

○サンプルコード3：finally節の使い方

例外処理において「try-catch」構文は基本中の基本として多くのプログラマーに知られていますが、この構文に加えて「finally」節というものが存在します。

これは、エラーが発生しようとしなかろうと、必ず実行されるコードブロックを記述するためのものです。

資源の解放や後処理など、エラーの有無に関わらず実行しなければならない処理を記述する際に非常に役立ちます。

TypeScriptにおける「finally」節の基本的な使用方法を紹介します。

try {
    console.log("try節: このコードは正常に実行されます。");
    // エラーを発生させる
    throw new Error("エラーが発生しました。");
} catch (e) {
    console.log("catch節: " + e.message);
} finally {
    console.log("finally節: このコードは必ず実行されます。");
}

このコードでは、まずtry節内でコンソールにメッセージを出力した後、意図的にエラーを発生させています。

次にcatch節でそのエラーを捕捉し、エラーメッセージを出力しています。

そして、finally節では、エラーの有無に関わらず実行されるメッセージを出力しています。

この例から、次のような動作の流れが確認できます。

「try節: このコードは正常に実行されます。」が出力される。
エラーが発生し、「catch節: エラーが発生しました。」が出力される。
「finally節: このコードは必ず実行されます。」が出力される。

このように、finally節内のコードはtryやcatch節の実行後、必ず実行されます。

これにより、例えばファイルのクローズ処理やデータベース接続の切断など、例外の発生に関係なく確実に行いたい後処理を記述することができます。

●例外の発生方法

例外処理の一つに、意図的にエラーを発生させる方法があります。

これにより、特定の条件下でエラーを出すことができ、期待したエラーが発生するか確認することが可能となります。

このようなエラーの発生方法を、TypeScriptでどのように実装するのか詳しく見ていきましょう。

○サンプルコード4：throwを用いた例外の発生

例外を発生させる際には、throw文を使用します。

この文を使用すると、プログラムの実行が中断され、最も近いcatch節に例外が渡されます。

throwを使用して特定の条件下でエラーを発生させるサンプルコードを紹介します。

function validateNumber(num: number) {
  // 数値が0より小さい場合、エラーをスロー
  if (num < 0) {
    throw new Error("数値は0以上である必要があります。");
  }
  return true;
}

try {
  validateNumber(-1); // この関数はエラーをスローします
} catch (error) {
  console.log(error.message); // エラーメッセージを出力
}

このコードでは、validateNumber関数を使って数値をチェックしています。

この例では、数値が0より小さい場合にエラーをスローしています。

したがって、validateNumber(-1)という関数呼び出しは、エラーを発生させます。

このエラーはtry-catch構文でキャッチされ、エラーメッセージがコンソールに出力されます。

実際にこのコードを実行すると、”数値は0以上である必要があります。”というメッセージがコンソールに表示されるでしょう。

throwを使ったエラー発生は、不正な入力や予期しない状況など、様々なシチュエーションで有用です。

しかしながら、過度に使用するとコードの読みやすさや保守性が低下する恐れもあります。

ですので、適切な場面での利用を心がけるようにしましょう。

○サンプルコード5：独自エラークラスの作成と使用

TypeScriptの例外処理の中でも、特にカスタムエラークラスの作成とその使用方法は非常に重要な部分となっています。

独自のエラークラスを作成することで、アプリケーションのエラーハンドリングをより具体的かつ効果的に行うことができます。

これにより、ユーザーエクスペリエンスの向上や、エラーの原因を特定しやすくするなどの利点が生まれます。

具体的には、独自エラークラスを使用することで次のようなメリットが得られます。

エラーの種類ごとに具体的なメッセージや対応方法を提供できる。
コード内でのエラーの発生箇所や原因を迅速に特定できる。
大規模なプロジェクトや複数の開発者が関与するプロジェクトでも、エラーハンドリングの統一感を持たせることができる。

さて、ここで具体的なサンプルコードを通じて、独自エラークラスの作成と使用方法について解説していきます。

// 独自のエラークラスを作成する
class NotFoundError extends Error {
    constructor(message: string) {
        super(message);
        this.name = 'NotFoundError'; // エラークラスの名前を設定する
    }
}

// エラーを発生させる関数
function findUser(userId: number) {
    // 仮のユーザーデータ
    const users = [
        { id: 1, name: 'Taro' },
        { id: 2, name: 'Hanako' }
    ];

    const user = users.find(u => u.id === userId);
    if (!user) {
        throw new NotFoundError(`ユーザーID${userId}は存在しません。`); // 独自のエラーをスローする
    }
    return user;
}

// 上記の関数を使用してエラーをキャッチする
try {
    const user = findUser(3); // 存在しないユーザーIDを指定
    console.log(user);
} catch (error) {
    if (error instanceof NotFoundError) {
        console.log(error.message); // エラーメッセージを表示する
    } else {
        console.log('未知のエラーが発生しました。');
    }
}

このコードでは、まずNotFoundErrorという独自のエラークラスを定義しています。

このエラークラスは、ユーザーが存在しない場合にスローされるエラーを表現しています。

findUser関数は、指定したユーザーIDに対応するユーザーが存在しない場合、このNotFoundErrorをスローします。

そして、try-catch構文を使用して、このエラーをキャッチし、エラーメッセージを表示しています。

エラーが発生すると、次のようなメッセージが表示されます。

ユーザーID3は存在しません。

このように、独自のエラークラスを使用することで、エラーハンドリングをより具体的に行うことができるのです。

実際のプロジェクトでも、このような方法でエラークラスを作成し、エラーハンドリングを効果的に行うことをおすすめします。

●例外処理の高度なテクニック

TypeScriptでの例外処理には、基本的なものから高度なものまで多様なテクニックが存在します。

特に非同期処理などの高度な場面では、エラーハンドリングが欠かせない要素となります。

ここでは、TypeScriptでの高度な例外処理のテクニックと、それに関連するサンプルコードを紹介していきます。

○サンプルコード6：非同期処理中の例外処理

非同期処理の中で例外が発生する場合、取り扱いが少し複雑になります。

Promiseやasync/awaitといった非同期処理の文法を使用する際、例外処理の仕方を知っておくことは非常に重要です。

async/awaitを用いた非同期処理中の例外処理のサンプルコードを紹介します。

async function fetchUserData(userId: string): Promise<string> {
    if (!userId) {
        throw new Error("ユーザーIDが指定されていません");
    }
    // ユーザーデータを取得する仮定の非同期処理
    return "ユーザーデータ";
}

async function main() {
    try {
        const userData = await fetchUserData("123");
        console.log(userData); // "ユーザーデータ"と表示
    } catch (error) {
        console.error("エラーが発生しました:", error.message);
    }
}

main();

このコードでは、fetchUserData関数内で条件に応じてエラーを発生させています。

この例では、userIdが指定されていない場合にエラーをスローします。

main関数内では、awaitを使用してfetchUserDataを呼び出し、その結果を待機しています。

もしfetchUserData内で例外が発生すれば、catchブロックでそのエラーをキャッチし、エラーメッセージをコンソールに出力します。

この例のように、async/awaitを使用する場合、非同期処理の中で発生するエラーも通常のtry-catch構文でキャッチすることができます。

このサンプルコードを実行すると、正しくユーザーデータが取得されれば、コンソールには”ユーザーデータ”と表示されます。

もしuserIdが指定されていない場合や、その他の理由でエラーが発生した場合は、”エラーが発生しました:”というメッセージとともに具体的なエラーメッセージがコンソールに表示されます。

○サンプルコード7：ネストされたtry-catch構文

TypeScriptにおける例外処理の知識を深める中で、複雑なロジックや外部リソースの扱いが増えてくると、try-catch構文がネストされることがあります。

ここでは、そのネストされたtry-catch構文の活用方法とその利点について解説します。

例として、外部APIを呼び出し、取得したデータをさらに別のAPIで処理するような場面を考えます。

第1のAPI呼び出しで例外が発生する場合と、第2のAPIで例外が発生する場合に異なるエラーハンドリングを行いたいとします。

function processData() {
    try {
        // 第1のAPI呼び出し
        const data = callFirstAPI();
        try {
            // 第2のAPI呼び出し
            const result = callSecondAPI(data);
            console.log("処理成功:", result);
        } catch (error2) {
            console.error("第2のAPIでのエラー:", error2.message);
        }
    } catch (error1) {
        console.error("第1のAPIでのエラー:", error1.message);
    }
}

このコードでは、外部APIを2つ呼び出すprocessData関数が定義されています。

最初のAPI呼び出しcallFirstAPIの結果を、次のAPIcallSecondAPIに渡しています。

それぞれのAPI呼び出しは独自のtry-catch構文で囲まれており、エラーが発生した場合にはそのエラー内容をコンソールに出力します。

さて、このコードの実行を考えると、もし第1のAPIが失敗した場合、”第1のAPIでのエラー:”というメッセージとともにエラー内容が表示されるでしょう。

一方、第1のAPIは成功しても第2のAPIでエラーが発生した場合は、”第2のAPIでのエラー:”というメッセージが表示されます。

ネストされたtry-catch構文の利点として、特定のコードブロックでのエラーハンドリングを細かく指定できることが挙げられます。

上記のようなシナリオでは、2つの異なるAPIのエラーハンドリングを独立して行いたい場合に非常に有用です。

ただし、ネストが深くなりすぎるとコードの可読性が低下するため、適切なネストの深さを保つことが重要です。

また、共通のエラーハンドリングロジックが多い場合は、関数として切り出して使い回すという方法も考えられます。

○サンプルコード8：条件を満たす場合に例外をスローする

TypeScriptの例外処理では、特定の条件が満たされた場合に、故意に例外をスローすることがあります。

これは、入力値が不正であるときや、プログラムの実行が意図したものとは異なる結果を生み出しそうな状況で、明示的にエラーを発生させて処理を停止させるための方法として使用されます。

では、具体的にどのように実装されるのか見ていきましょう。

// 数値が0未満の場合に例外をスローする関数
function checkNumber(num: number): void {
    // 数値が0未満の場合、エラーをスロー
    if (num < 0) {
        throw new Error('数値は0未満ではいけません。');
    }
    console.log('数値は正常です。');
}

try {
    // 関数を呼び出し、数値-1を渡す
    checkNumber(-1);
} catch (error) {
    console.log('エラーが発生しました:', error.message);
}

このコードではcheckNumberという関数を使って、数値が0未満かどうかを確認しています。0未満の場合、エラーをスローしています。

この例では、tryブロック内でcheckNumber(-1)として数値-1を渡すと、条件num < 0が真となり、例外がスローされます。

その結果、catchブロックが実行され、エラーメッセージがコンソールに表示されます。

コードを実際に実行すると、「エラーが発生しました: 数値は0未満ではいけません。」というメッセージが表示されます。

このように、TypeScriptでは条件を満たす場合に例外をスローすることで、意図しない動作やデータの破損を防ぐことができます。

特に、外部からの入力データのバリデーションや、プログラムの実行状態をチェックする際には、このような方法が頻繁に採用されます。

○サンプルコード9：外部ライブラリとの組み合わせ

TypeScriptでの例外処理は、独自のコードだけでなく、外部ライブラリとの組み合わせにも役立ちます。

今回は、一般的な外部ライブラリを利用しての例外処理を具体的に解説していきます。

特に、axiosという人気のHTTPクライアントとの組み合わせで、どのように例外を処理するかを解説します。

// 必要なライブラリをインポート
import axios from "axios";

async function fetchData(url: string): Promise<any> {
    try {
        // axiosを利用してデータを取得
        const response = await axios.get(url);
        return response.data;
    } catch (error) {
        // エラー発生時にはエラー情報を表示
        console.error("データの取得に失敗しました。", error);
        throw new Error("データ取得エラー");
    }
}

// 使用例
(async () => {
    const url = "https://api.example.com/data";
    try {
        const data = await fetchData(url);
        console.log("取得したデータ:", data);
    } catch (error) {
        console.error("エラーが発生:", error.message);
    }
})();

このコードでは、axiosを使って外部APIからデータを取得する関数fetchDataを定義しています。

関数内でtry-catch構文を用いて、API呼び出し時の例外をキャッチしています。

例外が発生した場合、エラーメッセージをコンソールに表示し、新たなエラーをthrowして呼び出し元に通知しています。

また、使用例として非同期即時関数を定義して、fetchDataを呼び出しています。

こちらでもtry-catch構文を使用して、fetchDataからthrowされたエラーをキャッチし、エラーメッセージをコンソールに表示しています。

この例から、外部ライブラリを使用する場面でも、TypeScriptの例外処理のメカニズムを利用して、適切にエラーを捕捉・処理することができることがわかります。

上記のサンプルコードを実行すると、正常にAPIからデータが取得できた場合、”取得したデータ:”というメッセージとともにデータがコンソールに表示されます。

一方、何らかの理由でエラーが発生した場合、”データの取得に失敗しました。”というメッセージとともにエラー詳細が表示され、その後”エラーが発生:”というメッセージとともに”データ取得エラー”というエラーメッセージが表示されます。

○サンプルコード10：例外処理を使ったデコレータの作成

TypeScriptの強力な機能の一つにデコレータがあります。

デコレータはクラス、メソッド、プロパティ、アクセサ、またはパラメータに注釈やメタデータを追加することができます。

例外処理と組み合わせることで、エラーハンドリングの効率を大幅に向上させることが可能です。

今回は、メソッドの実行時に例外が発生した場合に、それを捕捉し、代わりのデフォルト値を返すデコレータを作成してみましょう。

// デコレータ関数の定義
function HandleError(defaultValue: any) {
  return function (target: Object, propertyKey: string, descriptor: TypedPropertyDescriptor<any>) {
    // 元のメソッドを取得
    const originalMethod = descriptor.value;

    // ディスクリプタのvalueを書き換える
    descriptor.value = function (...args: any[]) {
      try {
        // 元のメソッドを呼び出し、その結果を返す
        return originalMethod.apply(this, args);
      } catch (error) {
        // エラーが発生した場合は、デフォルト値を返す
        console.error(`エラーが発生しました: ${error.message}`);
        return defaultValue;
      }
    };
    return descriptor;
  };
}

class Calculator {
  @HandleError(0)  // このデコレータはdivideメソッドに適用されます。
  divide(a: number, b: number): number {
    if (b === 0) throw new Error("0で割ることはできません。");
    return a / b;
  }
}

const calc = new Calculator();
console.log(calc.divide(10, 2));  // 5
console.log(calc.divide(10, 0));  // 0 (エラーメッセージがコンソールに表示され、デフォルト値の0が返される)

このコードでは、HandleErrorというデコレータを定義しています。

このデコレータはメソッドに適用される際、そのメソッドの実行中に例外が発生した場合に、指定されたデフォルト値を返すようにしています。

Calculatorクラスのdivideメソッドにこのデコレータを適用することで、0で割る操作を行った際に例外が発生しますが、その例外を捕捉し、代わりに0を返しています。

このように、デコレータを利用することで、クラスやメソッドの動作を柔軟にカスタマイズしたり、エラーハンドリングのロジックを一箇所に集約することができます。

上記のコードを実行すると、次のようになります。

calc.divide(10, 2)を実行すると、10を2で割った結果、5が正常に返されます。

一方、calc.divide(10, 0)を実行すると、「0で割ることはできません」というエラーメッセージがコンソールに表示され、デコレータで指定したデフォルト値の0が返されます。

これにより、使用者は例外処理に関する詳細を意識することなく、安全にメソッドを使用することができます。

●例外処理の注意点と対処法

例外処理を行う際、特にTypeScriptでの開発において、いくつかの注意点とその対処法が存在します。

ここではそれらを網羅的に見ていき、より安全なプログラムを書くためのヒントを提供します。

○過度なtry-catchの使用は避ける

TypeScriptをはじめ、多くのプログラム言語で例外処理は必要不可欠です。

しかし、try-catch構文を過度に使用すると、コードの読みやすさや保守性が低下する恐れがあります。

このコードでは、try-catch構文を多用しています。

// サンプルコード
function fetchData() {
  try {
    // データの取得
  } catch (error) {
    try {
      // エラーのロギング
    } catch (error) {
      // ロギングのエラー処理
    }
  }
}

上のコードでは、ネストされたtry-catchが見られます。

このような書き方は、処理の流れを追いにくくなるため、適切な例外処理の設計を行い、ネストを避けるようにしましょう。

○エラーメッセージは詳細に

エラーメッセージは、デバッグの大事な手がかりとなります。

具体的で詳細なエラーメッセージを設定することで、問題の原因を早く見つけ出せます。

// このコードでは、エラーメッセージを具体的に設定しています。
function divide(a: number, b: number): number {
  if (b === 0) {
    throw new Error('0での除算はできません。');
  }
  return a / b;
}

上の例では、0での除算が行われた際のエラーメッセージが明確になっています。

このように、エラーが発生した際の情報を具体的にすることで、デバッグがしやすくなります。

○例外のスコープを意識する

例外は、発生源に近い場所で捕捉することが一般的に推奨されます。

それにより、例外の原因やコンテキストを細かく捉えることができます。

// このコードでは、例外のスコープを狭く捉えています。
function processFile(fileName: string) {
  try {
    // ファイルのオープン
  } catch (error) {
    // オープンエラー処理
  }

  try {
    // ファイルの読み込み
  } catch (error) {
    // 読み込みエラー処理
  }
}

上の例では、ファイルのオープンと読み込みに対して、それぞれ別々のtry-catch構文を使用しています。

これにより、エラーの種類に応じた処理が容易になります。

●例外処理のカスタマイズ方法

例外処理はそのまま使用するだけでなく、カスタマイズを行うことでより効果的にエラー処理を行うことが可能です。

TypeScriptを使用すると、さまざまなカスタマイズの手法を利用できます。

ここでは、例外処理をカスタマイズする方法とその手法を実際のサンプルコードと共に詳しく解説します。

○サンプルコード1：エラーの情報を詳細にする

このコードでは、Errorクラスを継承して独自のエラークラスを作成します。

その際にエラー時の詳細な情報を含めることで、デバッグ時に有用な情報を得られます。

// 独自のエラークラスを作成
class DetailedError extends Error {
  constructor(public code: number, message?: string) {
    super(message);
    this.name = "DetailedError";
  }
}

try {
  throw new DetailedError(404, "ページが見つかりません");
} catch (error) {
  if (error instanceof DetailedError) {
    console.log(`エラーコード：${error.code}, メッセージ：${error.message}`);
  }
}

この例では、DetailedErrorという独自のエラークラスを作成しました。

このクラスにはエラーコードを示すcodeというプロパティが追加されています。

エラーが発生した際には、このエラーコードも一緒に表示され、どのようなエラーかを素早く理解する手助けとなります。

エラーコードとメッセージを一緒に表示するために、catchブロック内でエラーオブジェクトの型をチェックし、独自のエラークラスであるかどうかを確認しています。

実際に上記のコードを実行すると、エラーコード：404, メッセージ：ページが見つかりませんという出力が得られます。

これにより、エラーの原因や内容を迅速に把握することができます。

○サンプルコード2：外部ライブラリとの連携

例外処理をカスタマイズする際に、外部ライブラリを活用することでさらなる機能を追加することができます。

下記の例では、外部ライブラリを利用してエラーロギングを行います。

import { logError } from 'error-logging-library'; // 仮の外部ライブラリ名

try {
  // 何らかの処理
  throw new Error("何かのエラーが発生");
} catch (error) {
  logError(error);
}

このコードでは、error-logging-libraryという仮の外部ライブラリを使用しています。

catchブロック内でエラーオブジェクトをlogError関数に渡すことで、エラーの情報をログとして保存します。

このようにして、後からエラーの原因や詳細を調査する際の手助けとすることができます。

上記のコードを実行すると、エラーログが生成され、エラーの詳細がログに保存されます。

実際のライブラリを利用する際は、ドキュメントやAPIリファレンスを参照しながら適切に実装を行うことが重要です。

○サンプルコード3：独自のハンドリング方法の実装

TypeScriptの例外処理をカスタマイズすることで、特定のエラーに対して独自のハンドリング方法を実装することができます。

下記のコードは、特定のエラーメッセージに基づいて異なる処理を行う例です。

try {
  // 何らかの処理
  throw new Error("データベース接続エラー");
} catch (error) {
  if (error.message.includes("データベース")) {
    console.log("データベースに関連するエラーが発生しました。");
  } else {
    console.log("その他のエラーが発生しました。");
  }
}

この例では、エラーメッセージに”データベース”という文字列が含まれているかどうかでエラーの原因を判別し、それぞれ異なるメッセージを出力します。

このような方法を取ることで、エラーの原因に応じた適切な対応を簡単に実装することができます。

上記のコードを実行すると、エラーメッセージに応じて、データベースに関連するエラーが発生しました。

またはその他のエラーが発生しました。というメッセージが出力されます。

これにより、エラーの原因や内容を迅速に把握することができます。