MENU
  1. ホーム
  2. JavaScript
  3. JavaScriptでPromiseを使った非同期関数の作成方法を徹底解説

JavaScriptでPromiseを使った非同期関数の作成方法を徹底解説

JavaScript

JavaScriptの非同期処理は、ウェブ開発において非常に重要なスキルです。ユーザーの入力待ちやサーバーからのデータ取得など、非同期操作が多く発生します。その中で、Promiseは非同期処理を管理するための強力なツールです。Promiseを理解し、効果的に活用することで、コードの可読性と保守性が大幅に向上します。本記事では、JavaScriptのPromiseを使った非同期関数の作成方法を基本から応用まで徹底的に解説します。

目次

Promiseとは何か

Promiseは、JavaScriptにおける非同期処理を扱うためのオブジェクトです。Promiseは、非同期操作が完了したときに結果を返す約束を表現します。主に、非同期処理の成功（resolve）または失敗（reject）を表すために使用されます。非同期操作が完了すると、Promiseはそれに応じた値を持つ「解決済み」状態か、エラーを持つ「拒否済み」状態になります。Promiseを使うことで、非同期処理のコールバック地獄（callback hell）を避け、コードの可読性と保守性を向上させることができます。

基本的なPromiseの使い方

Promiseの基本的な使い方を理解することは、非同期処理を効果的に行うための第一歩です。以下に、Promiseの基本構文と使用例を示します。

Promiseの構文

Promiseは、new Promiseコンストラクタを使って作成されます。このコンストラクタは、resolveとrejectという2つの引数を取る関数を受け取ります。この関数内で非同期処理を行い、処理が成功した場合はresolveを、失敗した場合はrejectを呼び出します。

const myPromise = new Promise((resolve, reject) => {
    // 非同期処理
    let success = true; // これはサンプルです。実際の非同期処理結果に置き換えます。

    if (success) {
        resolve('成功しました！');
    } else {
        reject('エラーが発生しました');
    }
});

Promiseの使用例

上記のPromiseを使用するには、.thenメソッドと.catchメソッドを使います。.thenはPromiseが解決されたときに実行され、.catchはPromiseが拒否されたときに実行されます。

myPromise
    .then(result => {
        console.log(result); // "成功しました！" が出力されます
    })
    .catch(error => {
        console.error(error); // "エラーが発生しました" が出力されます
    });

このようにして、Promiseを使うことで非同期処理の結果を簡潔に扱うことができます。次に、実際にPromiseを使って非同期関数を作成する方法を見ていきましょう。

非同期関数の作成方法

Promiseを使って非同期関数を作成する方法を見ていきましょう。以下は、非同期処理を行う関数の例です。この例では、指定された時間後にメッセージを返す非同期関数を作成します。

基本的な非同期関数

以下の関数delayは、指定されたミリ秒後に解決されるPromiseを返します。

function delay(milliseconds) {
    return new Promise((resolve, reject) => {
        if (milliseconds < 0) {
            reject('時間は正の数でなければなりません');
        } else {
            setTimeout(() => {
                resolve(`指定された${milliseconds}ミリ秒が経過しました`);
            }, milliseconds);
        }
    });
}

この関数は、正の数のミリ秒を引数として受け取り、その時間が経過した後に解決されるPromiseを返します。もし負の数が渡された場合、Promiseは拒否されます。

非同期関数の使用例

上記のdelay関数を使用して、非同期処理を行う例を示します。

delay(2000)
    .then(message => {
        console.log(message); // "指定された2000ミリ秒が経過しました" が出力されます
    })
    .catch(error => {
        console.error(error); // エラーが発生した場合、そのメッセージが出力されます
    });

この例では、delay関数が呼び出され、2秒後にPromiseが解決され、メッセージがコンソールに出力されます。

非同期処理を連続して実行する

複数の非同期処理を連続して実行する場合、Promiseチェーンを利用することができます。

delay(1000)
    .then(() => {
        console.log('1秒経過');
        return delay(2000);
    })
    .then(() => {
        console.log('さらに2秒経過');
        return delay(3000);
    })
    .then(() => {
        console.log('さらに3秒経過');
    })
    .catch(error => {
        console.error(error);
    });

この例では、最初に1秒、次に2秒、最後に3秒の遅延が発生し、それぞれの遅延後にメッセージが出力されます。Promiseチェーンを使うことで、非同期処理を直列に実行することが容易になります。次に、Promiseをより簡単に扱うためのasync/await構文について説明します。

async/awaitの使い方

Promiseをより直感的に扱うために、JavaScriptではasync/await構文が導入されました。この構文を使用することで、非同期処理をまるで同期処理のように記述することができます。

async/awaitの基本構文

asyncキーワードを関数の前に付けることで、その関数は常にPromiseを返す非同期関数になります。awaitキーワードは、Promiseが解決されるまで関数の実行を一時停止し、その結果を取得します。以下は、基本的な構文の例です。

async function myAsyncFunction() {
    try {
        const result = await somePromiseFunction();
        console.log(result);
    } catch (error) {
        console.error(error);
    }
}

例: delay関数を使った非同期処理

前述のdelay関数を使って、async/await構文を利用する例を示します。

async function runDelays() {
    try {
        console.log('開始');
        await delay(1000);
        console.log('1秒経過');
        await delay(2000);
        console.log('さらに2秒経過');
        await delay(3000);
        console.log('さらに3秒経過');
    } catch (error) {
        console.error(error);
    }
}

runDelays();

この例では、runDelays関数が順次遅延を実行し、それぞれの遅延後にメッセージを出力します。awaitキーワードを使用することで、Promiseの解決を待ってから次の処理に進むことができ、非同期処理をシンプルに記述できます。

非同期関数のエラーハンドリング

async/awaitを使った場合のエラーハンドリングも簡単です。try/catch構文を使って、非同期処理中に発生するエラーをキャッチします。

async function errorHandlingExample() {
    try {
        const result = await delay(-1000); // ここでエラーが発生します
        console.log(result);
    } catch (error) {
        console.error('エラー:', error); // "エラー: 時間は正の数でなければなりません" が出力されます
    }
}

errorHandlingExample();

このようにして、async/await構文を使うことで、非同期処理をより直感的で読みやすい形で記述することができます。次に、Promiseにおけるエラーハンドリングの詳細とベストプラクティスについて説明します。

エラーハンドリング

Promiseにおけるエラーハンドリングは、非同期処理を安全に行うために非常に重要です。エラーが適切に処理されないと、アプリケーションが不安定になったり、ユーザーに悪影響を与える可能性があります。ここでは、Promiseのエラーハンドリング方法とベストプラクティスを紹介します。

Promiseのエラーハンドリング方法

Promiseのエラーハンドリングは、.catchメソッドを使って行います。.catchメソッドは、Promiseが拒否された場合に実行されるコールバック関数を受け取ります。

const myPromise = new Promise((resolve, reject) => {
    // 非同期処理
    let success = false; // 成功を false に設定してエラーをシミュレート

    if (success) {
        resolve('成功しました！');
    } else {
        reject('エラーが発生しました');
    }
});

myPromise
    .then(result => {
        console.log(result);
    })
    .catch(error => {
        console.error('エラー:', error); // "エラー: エラーが発生しました" が出力されます
    });

複数の非同期処理におけるエラーハンドリング

複数の非同期処理を行う場合、それぞれの処理に対してエラーハンドリングを行うことが重要です。Promiseチェーンを使用する場合、各処理に対して.catchメソッドを追加します。

delay(1000)
    .then(() => {
        console.log('1秒経過');
        return delay(2000);
    })
    .then(() => {
        console.log('さらに2秒経過');
        return delay(3000);
    })
    .then(() => {
        console.log('さらに3秒経過');
    })
    .catch(error => {
        console.error('エラー:', error); // どのPromiseが失敗してもここでキャッチされます
    });

async/awaitを使ったエラーハンドリング

async/await構文を使う場合、try/catchブロックを使ってエラーをキャッチします。これにより、同期的なコードと同じようにエラーハンドリングを行うことができます。

async function runDelaysWithErrorHandling() {
    try {
        await delay(1000);
        console.log('1秒経過');
        await delay(-2000); // ここでエラーが発生します
        console.log('さらに2秒経過');
    } catch (error) {
        console.error('エラー:', error); // "エラー: 時間は正の数でなければなりません" が出力されます
    }
}

runDelaysWithErrorHandling();

この例では、delay関数に負の値を渡してエラーを発生させ、catchブロックでそのエラーをキャッチしています。

ベストプラクティス

  1. 常にエラーハンドリングを行う: 非同期処理のすべてのPromiseに対して.catchを追加し、エラーが見逃されないようにします。
  2. 具体的なエラーメッセージを提供する: ユーザーや開発者がエラーの原因を迅速に理解できるよう、明確で詳細なエラーメッセージを提供します。
  3. 一貫性を保つ: コードベース全体で一貫したエラーハンドリング方法を使用します。async/awaitを使用する場合は、try/catchブロックを統一的に使用します。

これらのベストプラクティスを守ることで、非同期処理の信頼性と可読性を向上させることができます。次に、Promiseを使った実践的なAPI呼び出しの例を紹介します。

実践例: API呼び出し

Promiseを使った非同期処理の具体例として、API呼び出しを行う方法を見ていきましょう。ここでは、fetch関数を使って外部APIからデータを取得する例を紹介します。

fetch関数を使ったAPI呼び出し

fetch関数は、Promiseを返すため、API呼び出しに非常に便利です。以下の例では、APIからユーザー情報を取得し、その結果をコンソールに出力します。

function fetchUserData(userId) {
    return fetch(`https://jsonplaceholder.typicode.com/users/${userId}`)
        .then(response => {
            if (!response.ok) {
                throw new Error('ネットワーク応答が正しくありません');
            }
            return response.json();
        })
        .then(data => {
            console.log('ユーザーデータ:', data);
            return data;
        })
        .catch(error => {
            console.error('エラー:', error);
        });
}

fetchUserData(1);

この例では、fetch関数がPromiseを返し、最初の.thenでレスポンスのステータスを確認し、response.json()メソッドを使ってJSONデータに変換しています。次の.thenでデータを処理し、catchでエラーをキャッチします。

async/awaitを使ったAPI呼び出し

async/awaitを使って同じAPI呼び出しを行うと、さらにシンプルで読みやすいコードになります。

async function fetchUserDataAsync(userId) {
    try {
        const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
        if (!response.ok) {
            throw new Error('ネットワーク応答が正しくありません');
        }
        const data = await response.json();
        console.log('ユーザーデータ:', data);
        return data;
    } catch (error) {
        console.error('エラー:', error);
    }
}

fetchUserDataAsync(1);

この例では、awaitキーワードを使って非同期処理を同期的に書くことができます。fetch関数の結果を待ち、その後にJSONデータに変換し、結果を処理します。エラーが発生した場合は、try/catchブロックでキャッチされます。

複数のAPI呼び出しを連続して行う

複数のAPI呼び出しを順次行う場合、Promiseチェーンやasync/awaitを使って簡潔に記述できます。

async function fetchMultipleUsers() {
    try {
        const user1 = await fetchUserDataAsync(1);
        const user2 = await fetchUserDataAsync(2);
        console.log('ユーザー1と2のデータ:', user1, user2);
    } catch (error) {
        console.error('エラー:', error);
    }
}

fetchMultipleUsers();

この例では、fetchUserDataAsync関数を連続して呼び出し、それぞれの結果を取得してコンソールに出力しています。async/await構文を使うことで、非同期処理を直感的に記述することができます。

これで、Promiseを使った実践的なAPI呼び出しの方法が理解できました。次に、非同期処理のパフォーマンス最適化について説明します。

パフォーマンスの最適化

非同期処理を行う際、パフォーマンスの最適化は非常に重要です。特に、大規模なアプリケーションや多数の非同期操作を行う場合、適切な最適化を行わないと、レスポンスの遅延やリソースの無駄遣いにつながる可能性があります。ここでは、非同期処理のパフォーマンスを最適化するためのいくつかの方法を紹介します。

並列処理

複数の非同期操作を並列に実行することで、全体の処理時間を短縮できます。Promise.allを使うことで、複数のPromiseを同時に処理することが可能です。

async function fetchMultipleUsersParallel() {
    try {
        const userPromises = [fetchUserDataAsync(1), fetchUserDataAsync(2), fetchUserDataAsync(3)];
        const users = await Promise.all(userPromises);
        console.log('すべてのユーザーデータ:', users);
    } catch (error) {
        console.error('エラー:', error);
    }
}

fetchMultipleUsersParallel();

この例では、fetchUserDataAsync関数を3回呼び出し、その結果をPromise.allで待ちます。これにより、3つのAPI呼び出しが並列に実行され、全体の待ち時間が短縮されます。

遅延ロード

必要なデータだけを遅延ロードすることで、初期ロード時のパフォーマンスを向上させることができます。例えば、ユーザーが特定の操作を行ったときにのみデータをロードするようにします。

document.getElementById('loadUserDataButton').addEventListener('click', async () => {
    try {
        const user = await fetchUserDataAsync(1);
        console.log('遅延ロードされたユーザーデータ:', user);
    } catch (error) {
        console.error('エラー:', error);
    }
});

この例では、ボタンがクリックされたときにのみfetchUserDataAsync関数が実行され、ユーザーデータがロードされます。

キャッシング

頻繁に使用するデータをキャッシュすることで、API呼び出しの回数を減らし、パフォーマンスを向上させることができます。

const userCache = {};

async function fetchUserDataWithCache(userId) {
    if (userCache[userId]) {
        return userCache[userId];
    }
    const user = await fetchUserDataAsync(userId);
    userCache[userId] = user;
    return user;
}

async function displayUserData(userId) {
    try {
        const user = await fetchUserDataWithCache(userId);
        console.log('キャッシュを使用したユーザーデータ:', user);
    } catch (error) {
        console.error('エラー:', error);
    }
}

displayUserData(1);
displayUserData(1); // 2回目の呼び出しではキャッシュされたデータが使用される

この例では、ユーザーデータをキャッシュし、同じユーザーIDでの複数回の呼び出しに対してキャッシュを利用することで、API呼び出しの回数を削減しています。

非同期処理のキャンセル

不要になった非同期処理をキャンセルすることで、リソースの無駄遣いを防ぎます。AbortControllerを使用して、fetchリクエストをキャンセルする方法を示します。

const controller = new AbortController();
const signal = controller.signal;

async function fetchUserDataWithCancel(userId) {
    try {
        const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`, { signal });
        if (!response.ok) {
            throw new Error('ネットワーク応答が正しくありません');
        }
        const data = await response.json();
        console.log('キャンセル可能なユーザーデータ:', data);
        return data;
    } catch (error) {
        if (error.name === 'AbortError') {
            console.log('Fetchリクエストがキャンセルされました');
        } else {
            console.error('エラー:', error);
        }
    }
}

// 5秒後にリクエストをキャンセルする
setTimeout(() => controller.abort(), 5000);

fetchUserDataWithCancel(1);

この例では、5秒後にfetchリクエストがキャンセルされ、リソースの無駄遣いを防ぎます。

これらの最適化技術を用いることで、非同期処理のパフォーマンスを大幅に向上させることができます。次に、複数のPromiseを一度に扱う方法として、Promise.allとPromise.raceの使い方について説明します。

Promise.allとPromise.race

複数のPromiseを一度に扱う場合、Promise.allとPromise.raceを使用すると便利です。これらのメソッドを使うことで、非同期処理を効率的に管理できます。

Promise.all

Promise.allは、複数のPromiseがすべて解決されるのを待ってから次の処理を行います。すべてのPromiseが解決されると、結果の配列が返されます。いずれかのPromiseが拒否されると、Promise.allも拒否され、そのエラーが返されます。

async function fetchMultipleUsersWithAll() {
    try {
        const userIds = [1, 2, 3];
        const userPromises = userIds.map(id => fetchUserDataAsync(id));
        const users = await Promise.all(userPromises);
        console.log('すべてのユーザーデータ:', users);
    } catch (error) {
        console.error('エラー:', error);
    }
}

fetchMultipleUsersWithAll();

この例では、fetchUserDataAsyncを複数回呼び出し、その結果をPromise.allで待っています。すべてのAPI呼び出しが成功すると、ユーザーデータが配列として返されます。

Promise.race

Promise.raceは、複数のPromiseのうち最初に解決または拒否されたものを返します。最初に完了したPromiseの結果が返され、他のPromiseは無視されます。

async function fetchFastestUser() {
    try {
        const userPromises = [
            fetchUserDataAsync(1),
            fetchUserDataAsync(2),
            fetchUserDataAsync(3)
        ];
        const fastestUser = await Promise.race(userPromises);
        console.log('最初に取得されたユーザーデータ:', fastestUser);
    } catch (error) {
        console.error('エラー:', error);
    }
}

fetchFastestUser();

この例では、3つのAPI呼び出しのうち最初に完了したものの結果を返します。これにより、最も早く応答したAPIからのデータを取得できます。

Promise.allSettled

Promise.allSettledは、すべてのPromiseが完了するのを待ち、各Promiseの結果を配列として返します。各結果は、解決されたか拒否されたかに関係なくオブジェクトとして含まれます。

async function fetchAllUsersWithAllSettled() {
    const userPromises = [
        fetchUserDataAsync(1),
        fetchUserDataAsync(2),
        fetchUserDataAsync(3)
    ];
    const results = await Promise.allSettled(userPromises);
    results.forEach((result, index) => {
        if (result.status === 'fulfilled') {
            console.log(`ユーザー${index + 1}:`, result.value);
        } else {
            console.error(`ユーザー${index + 1}の取得に失敗:`, result.reason);
        }
    });
}

fetchAllUsersWithAllSettled();

この例では、すべてのPromiseが完了するまで待ち、それぞれの結果を処理しています。成功したものと失敗したものの両方が含まれるため、すべての結果を詳細に確認できます。

Promise.any

Promise.anyは、複数のPromiseのうち最初に解決されたものを返します。すべてのPromiseが拒否された場合のみエラーが返されます。

async function fetchAnyUser() {
    const userPromises = [
        fetchUserDataAsync(1),
        fetchUserDataAsync(2),
        fetchUserDataAsync(3)
    ];
    try {
        const firstResolvedUser = await Promise.any(userPromises);
        console.log('最初に解決されたユーザーデータ:', firstResolvedUser);
    } catch (error) {
        console.error('すべてのユーザーデータ取得に失敗:', error);
    }
}

fetchAnyUser();

この例では、最初に解決されたPromiseの結果を取得します。すべてのPromiseが拒否された場合にはエラーが発生します。

これらのメソッドを使うことで、複数のPromiseを効果的に管理し、非同期処理をより柔軟に扱うことができます。次に、Promiseを使う際によくある間違いとその対策について説明します。

よくある間違いとその対策

Promiseを使用する際に初心者が陥りやすい間違いや、経験者でも見落としがちなポイントがあります。これらの間違いを避けるための対策を以下に紹介します。

間違い1: Promiseのネスト

Promiseをネストしてしまうと、コードが読みにくくなり、デバッグが困難になります。Promiseチェーンを使ってフラットな構造にすることが重要です。

悪い例:

fetchUserDataAsync(1)
    .then(user1 => {
        fetchUserDataAsync(2)
            .then(user2 => {
                console.log('ユーザー1とユーザー2のデータ:', user1, user2);
            });
    });

良い例:

fetchUserDataAsync(1)
    .then(user1 => {
        return fetchUserDataAsync(2).then(user2 => {
            console.log('ユーザー1とユーザー2のデータ:', user1, user2);
        });
    })
    .catch(error => {
        console.error('エラー:', error);
    });

このように、Promiseチェーンを使うことで、コードをフラットに保ち、可読性を向上させます。

間違い2: エラーハンドリングの不足

Promiseチェーンのどこかでエラーハンドリングを忘れると、エラーが見逃される可能性があります。各Promiseに対して適切にエラーハンドリングを行うことが重要です。

悪い例:

fetchUserDataAsync(1)
    .then(user1 => {
        return fetchUserDataAsync(2);
    })
    .then(user2 => {
        console.log('ユーザー1とユーザー2のデータ:', user1, user2);
    });

良い例:

fetchUserDataAsync(1)
    .then(user1 => {
        return fetchUserDataAsync(2);
    })
    .then(user2 => {
        console.log('ユーザー1とユーザー2のデータ:', user1, user2);
    })
    .catch(error => {
        console.error('エラー:', error);
    });

すべてのPromiseチェーンの最後に.catchを追加することで、エラーが確実にキャッチされるようにします。

間違い3: 不必要なPromiseの使用

非同期関数をasyncキーワードで宣言すると、自動的にPromiseを返すため、不要なPromiseを作成しないように注意が必要です。

悪い例:

async function fetchUserDataAndLog(userId) {
    return new Promise((resolve, reject) => {
        fetchUserDataAsync(userId)
            .then(user => {
                console.log(user);
                resolve(user);
            })
            .catch(error => {
                reject(error);
            });
    });
}

良い例:

async function fetchUserDataAndLog(userId) {
    try {
        const user = await fetchUserDataAsync(userId);
        console.log(user);
        return user;
    } catch (error) {
        throw error;
    }
}

async関数は自動的にPromiseを返すため、明示的に新しいPromiseを作成する必要はありません。

間違い4: 同期的なループ内でのawait

forループ内でawaitを使うと、ループが逐次的に実行され、パフォーマンスが低下します。並列処理を行うためには、Promise.allとmapを組み合わせて使用します。

悪い例:

async function fetchAllUserData(userIds) {
    for (let id of userIds) {
        const user = await fetchUserDataAsync(id);
        console.log(user);
    }
}

良い例:

async function fetchAllUserData(userIds) {
    const userPromises = userIds.map(id => fetchUserDataAsync(id));
    const users = await Promise.all(userPromises);
    users.forEach(user => console.log(user));
}

このようにすることで、すべてのユーザー情報を並列に取得し、処理速度を向上させます。

これらの対策を実践することで、Promiseを使った非同期処理をより効果的に行うことができます。次に、Promiseの理解を深めるための練習問題を提供します。

練習問題

Promiseの理解を深めるために、いくつかの練習問題を用意しました。これらの問題に取り組むことで、Promiseの基本的な使い方から応用的な使い方までを実践的に学ぶことができます。

問題1: 基本的なPromiseの作成と使用

以下のコードを完成させ、2秒後に”Hello, Promise!”というメッセージをコンソールに表示するPromiseを作成してください。

function sayHello() {
    return new Promise((resolve, reject) => {
        // ここにコードを追加
    });
}

sayHello().then(message => {
    console.log(message); // "Hello, Promise!" が出力される
});

問題2: 非同期関数の作成

setTimeoutを使用して、指定された時間後にメッセージを表示する非同期関数waitAndSayを作成してください。関数はasyncキーワードを使用して定義します。

async function waitAndSay(message, milliseconds) {
    // ここにコードを追加
}

waitAndSay('Hello after 3 seconds', 3000);

問題3: 複数のAPI呼び出しを並列に実行

以下のAPIエンドポイントからデータを取得し、それぞれの結果をコンソールに表示する関数fetchMultipleDataを作成してください。Promise.allを使用して、並列に実行してください。

const apiEndpoints = [
    'https://jsonplaceholder.typicode.com/posts/1',
    'https://jsonplaceholder.typicode.com/posts/2',
    'https://jsonplaceholder.typicode.com/posts/3'
];

async function fetchMultipleData(urls) {
    // ここにコードを追加
}

fetchMultipleData(apiEndpoints);

問題4: エラーハンドリング

以下の非同期関数fetchDataWithErrorを修正して、エラーが発生した場合に”Error occurred”というメッセージをコンソールに表示するようにしてください。

async function fetchDataWithError() {
    const response = await fetch('https://jsonplaceholder.typicode.com/invalid-url');
    const data = await response.json();
    return data;
}

fetchDataWithError().catch(error => {
    // ここにコードを追加
});

問題5: Promise.raceの使用

複数のPromiseのうち、最初に解決されたものの結果を表示する関数fetchFastestDataを作成してください。

const slowPromise = new Promise(resolve => setTimeout(() => resolve('Slow Promise'), 2000));
const fastPromise = new Promise(resolve => setTimeout(() => resolve('Fast Promise'), 1000));

async function fetchFastestData(promises) {
    // ここにコードを追加
}

fetchFastestData([slowPromise, fastPromise]);

これらの問題に取り組むことで、Promiseと非同期処理に関する理解が深まるでしょう。次に、本記事のまとめに移ります。

まとめ

本記事では、JavaScriptにおけるPromiseを使った非同期関数の作成方法について、基本から応用まで詳細に解説しました。Promiseの基本概念や使い方、async/await構文、エラーハンドリングの方法、実践的なAPI呼び出しの例、パフォーマンスの最適化、そして複数のPromiseを扱うためのPromise.allとPromise.raceについて学びました。また、よくある間違いとその対策、理解を深めるための練習問題も紹介しました。Promiseを適切に使用することで、非同期処理をより効果的かつ効率的に行うことができ、コードの可読性と保守性が向上します。この記事を参考に、実際のプロジェクトでPromiseを活用し、非同期処理を自在に扱えるようになりましょう。

JavaScript
非同期処理 JavaScript Promise

コメント

コメントする

目次