TypeScriptのasync/await戻り値の型定義とPromiseの扱い方まとめ

TypeScriptにおいて、非同期処理を安全かつ効率的に実装することは、堅牢なアプリケーション開発の基盤となります。

特に、async/await構文を利用した際の戻り値の型定義は、コードの可読性と保守性を左右する重要な要素です。

2026年のモダンな開発現場では、型推論に頼るだけでなく、明示的な型定義を行うことで、チーム開発におけるコミュニケーションコストを削減する手法が一般的となっています。

本記事では、非同期関数の基本的な戻り値の型から、複雑な並列処理、最新のユーティリティ型を活用した高度な定義方法まで、実務に即した知識を整理して解説します。

async/await関数の基本と戻り値の型

TypeScriptのasyncキーワードを付与した関数は、必ずPromiseオブジェクトを返却します。

関数内で値を直接returnしたとしても、TypeScriptコンパイラはその値をPromiseでラップして扱います。

そのため、非同期関数の戻り値の型を定義する際は、必ずPromise<T>の形式を使用する必要があります。

明示的な戻り値の型定義

戻り値の型を明示することで、関数が何を返すべきかをコンパイラと開発者の双方に明確に伝えることができます。

async function fetchUserName(id: number): Promise<string> {
    // 擬似的な非同期処理
    return new Promise((resolve) => {
        setTimeout(() => resolve(`User_${id}`), 1000);
    });
}

const result = fetchUserName(123);
console.log(result); // Promise<string>型が返る

Promise { <pending> }

このように、Promise<string>と指定することで、この関数が最終的に文字列を返す非同期処理であることが保証されます。

型推論の活用と注意点

TypeScriptは強力な型推論機能を持っているため、戻り値の型を省略することも可能です。

しかし、大規模なプロジェクトやAPIとの通信を行う関数では、明示的に型を記述することが推奨されます。

型を省略すると、関数の実装を変更した際に意図しない型として推論され、呼び出し側で予期せぬエラーが発生するリスクが高まるからです。

複雑な戻り値の型を扱う手法

実際の開発では、単一のプリミティブ型だけでなく、オブジェクトやユニオン型を非同期で返す場面が多く存在します。

オブジェクトを返す非同期関数

APIから取得したデータなど、構造化されたデータを返す場合は、インターフェースや型別名（Type Alias）を併用します。

interface UserProfile {
    id: number;
    name: string;
    email: string;
}

async function getUserProfile(id: number): Promise<UserProfile> {
    const response = await fetch(`https://api.example.com/users/${id}`);
    const data: UserProfile = await response.json();
    return data;
}

インターフェースを用いることで、Promise<UserProfile>という直感的な型定義が可能になります。

複数の型が返る可能性がある場合

条件によって異なる型の値を返す場合は、ユニオン型を使用して定義します。

例えば、データが存在しない場合にnullを返すようなケースです。

async function findItem(id: string): Promise<string | null> {
    if (id === "exists") {
        return "Item Found";
    }
    return null;
}

呼び出し側では、awaitで値を取り出した後にnullチェックを行うことが型安全性の観点から必須となります。

Promiseの静的メソッドと型定義

複数の非同期処理を並列で実行する場合、Promise.allやPromise.allSettledの戻り値の型を正しく理解することが重要です。

Promise.allによる並列実行

Promise.allは、渡されたすべてのPromiseが完了した際に、その結果を配列として返します。

async function fetchMultipleData(): Promise<[string, number]> {
    const stringPromise = Promise.resolve("Hello");
    const numberPromise = Promise.resolve(100);

    // タプル型として推論される
    const results = await Promise.all([stringPromise, numberPromise]);
    return results;
}

Promise.allに渡す配列の要素が異なる型であっても、TypeScriptはタプル型として正確に推論してくれます。

Promise.allSettledの活用

2026年の開発シーンにおいて、一部の処理が失敗しても全体の処理を継続したい場合には、Promise.allSettledが多用されます。

このメソッドの戻り値は、各Promiseの状態（fulfilledまたはrejected）を示すオブジェクトの配列となります。

この型定義は自動的に適用されますが、結果をフィルタリングする際にはユーザー定義型ガードなどを用いるとスムーズに処理できます。

Awaitedユーティリティ型の活用

TypeScript 4.5から導入されたAwaited<T>型は、再帰的にPromiseを解きほぐし、最終的な値の型を取り出すために使用されます。

Awaitedが必要なシーン

他のライブラリが提供する関数の戻り値から、中身の型だけを抽出したい場合に非常に便利です。

type ApiResult = Promise<Promise<string>>;

// Awaitedを使わない場合、Promise<string>が残る可能性がある
type FinalResult = Awaited<ApiResult>; // string型になる

Awaited<T>を使用することで、ネストされたPromiseであっても確実に「待機後の型」を取得できます。

これは、ジェネリクスを用いた高度なコンポーネント設計や、共通の非同期ラッパー関数を作成する際に欠かせないテクニックです。

非同期関数におけるエラーハンドリングと型

非同期関数におけるエラー（例外）は、型定義だけでは捕捉できない側面があります。

try-catchによる制御

async/awaitではtry-catch構文を用いてエラーを捕捉しますが、catch節のerror変数の型はデフォルトでunknownとなります。

async function safeFetch(): Promise<string> {
    try {
        const response = await fetch("https://invalid-url.com");
        return await response.text();
    } catch (error) {
        if (error instanceof Error) {
            return `Error: ${error.message}`;
        }
        return "Unknown error occurred";
    }
}

エラーが発生した場合でも特定の型を返すように設計することで、関数のシグネチャを崩さずにエラーハンドリングが可能です。

Result型パターンによる安全な戻り値

近年では、例外をスローするのではなく、成功と失敗を型で表現する「Result型」パターンも人気があります。

type AsyncResult<T> = Promise<{ success: true; data: T } | { success: false; error: string }>;

async function fetchWithResult(): AsyncResult<number> {
    try {
        return { success: true, data: 200 };
    } catch (e) {
        return { success: false, error: "Fetch failed" };
    }
}

この手法を導入すると、呼び出し側で必ず成功・失敗の判定を強制できるため、ランタイムエラーを劇的に減らすことができます。

実践的なベストプラクティス

TypeScriptの非同期関数をより洗練させるためのポイントをいくつか紹介します。

Void型を返す非同期関数

値を返さない非同期関数の場合、戻り値の型はPromise<void>と定義します。

これは、単に「処理の完了」だけを待機したい場合に適しています。

関数のオーバーロードの回避

非同期関数において、引数によって戻り値のPromiseの中身が大きく変わるような設計は避けるべきです。

可能な限り、1つの関数には1つの明確な責務を持たせ、戻り値の型をシンプルに保つことが、コードの健読性を維持する秘訣です。

Top-level awaitの活用

2026年現在、モジュールの直下でawaitを使用する「Top-level await」は標準的に利用されています。

これにより、エントリーポイントとなるスクリプトでわざわざasync関数を定義して即時実行する必要がなくなりました。

ただし、モジュールの読み込み自体が非同期になるため、依存関係の循環には引き続き注意が必要です。

まとめ

TypeScriptにおけるasync/awaitの戻り値の型定義は、単にPromiseと書くだけでなく、その中身をいかに厳密に定義するかが鍵となります。

ジェネリクスを用いたPromise<T>の基本から、Awaited<T>による型の抽出、さらにはResult型パターンによる安全なエラー制御まで、幅広いアプローチが存在します。

開発の規模や要件に合わせて最適な定義方法を選択することで、型安全性の恩恵を最大限に受けることができます。

特にチーム開発においては、戻り値の型を明示する習慣をつけることが、バグの早期発見とスムーズなリファクタリングに直結します。

今回紹介したテクニックを活用し、より洗練されたTypeScriptコードの記述を目指してください。