JavaScriptの非同期処理入門|Promise・async/awaitの使い方
JavaScript を書いていると、「console.log の順番がコードの順番と違う」「関数の結果が Promise という見慣れないものになる」「await を付けたのに待ってくれない」といった場面に出会います。どれも非同期処理の仕組みを知ると理由が分かります。
この記事では、JavaScript の非同期処理を、ブラウザの開発者ツールのコンソールで試せるコードと実行結果つきで解説します。通信の代わりに setTimeout で待つ関数を使うので、インターネット上のサーバーにアクセスせずに安全に試せます。
実行結果は、Microsoft Edge 155(Chromium 版)のヘッドレスモードで実際に動かして確かめたものです。時間(「1.01 秒」など)は環境によって少し変わります。
コードの試し方(開発者ツールのコンソール)
- Chrome か Edge で、どのページでもよいので開き、キーボードの F12 キーを押します。
- 開いた画面の上部にある「Console(コンソール)」タブを選びます。
- この記事のコードをコピーして貼り付け、Enter キーを押します。
コンソールは console.log の出力のほかに、最後の式の値(undefined や Promise)も 1 行表示しますが、この記事の実行結果では省いています。続けて試すときは F5 キーで再読み込みしてから貼ると、前のコードの影響を受けません。
初めて貼り付けるとき、詐欺を防ぐための警告が出て、確認の文字の入力を求められることがあります。知らない人から教えられたコードは、絶対にコンソールに貼り付けないでください。
非同期処理とは:待ち時間で止まらずに先へ進む
ブラウザの JavaScript は、基本的に1 本の流れ(シングルスレッド)でコードを実行します。料理店に例えると、店員が 1 人しかいない状態です。この店員が「料理ができるまで厨房の前でじっと待つ」と、その間はほかのお客さんの注文を受けられません。
そこで JavaScript は、時間のかかる待ち(タイマー、通信の返事、ファイルの読み込みなど)を「終わったら呼んでね」と頼んでおき、待っている間に次のコードを進めます。これが非同期処理です。setTimeout で確かめてみます。
console.log("1. 注文を受ける");
setTimeout(() => {
console.log("3. 料理ができた(2 秒後)");
}, 2000);
console.log("2. 次のお客さんの注文を受ける");
1. 注文を受ける
2. 次のお客さんの注文を受ける
3. 料理ができた(2 秒後)
1 と 2 はすぐに表示され、3 だけが約 2 秒後(実測 2.01 秒)に表示されました。setTimeout は「2000 ミリ秒後にこの関数を実行して」と予約するだけで、待たずにすぐ次の行へ進むからです。
ただし、店員は 1 人なので「同時に動いている」わけではありません。試しに、100 ミリ秒後に予約したタイマーの直後に 1 秒間ひたすら計算し続けるループを置くと、タイマーが動いたのは 1000 ミリ秒後でした。非同期処理で短くなるのは通信やタイマーなどの待ち時間だけで、重い計算そのものは速くなりません。
コールバック関数と「コールバック地獄」
setTimeout に渡した「終わったら実行してほしい関数」をコールバック関数と呼びます。昔の JavaScript では、非同期処理の結果をコールバック関数で受け取るのが基本でした。
ところが「ユーザー情報を取得 → その結果で注文履歴を取得 → その結果でおすすめ商品を取得」のように順番に行う処理を書くと、コールバックの中にコールバックが入り、どんどん右にずれていきます(ここでは 1 秒待つことで通信の代わりにしています)。
setTimeout(() => {
console.log("ユーザー情報を取得");
setTimeout(() => {
console.log("注文履歴を取得");
setTimeout(() => {
console.log("おすすめ商品を取得");
}, 1000);
}, 1000);
}, 1000);
「ユーザー情報を取得」「注文履歴を取得」「おすすめ商品を取得」が、1 秒ごとに 1 行ずつ表示されます(実測 1.01 秒・2.01 秒・3.03 秒)。動きは正しいのですが、段数が増えるほど読みにくく、エラー処理も段ごとに書く必要があります。この状態は「コールバック地獄」と呼ばれ、これを解決するために作られたのが Promise です。
Promise の基本:「あとで結果を渡す」という約束
Promise(プロミス)は、「今はまだ結果がないけれど、終わったら結果(または失敗の理由)を渡します」という約束を表すオブジェクトです。MDN(Mozilla の公式リファレンス)では、Promise は次の 3 つの状態のどれかにあると説明されています。
| 状態 | 意味 | どうなると移るか |
|---|---|---|
| pending(待機中) | まだ終わっていない最初の状態 | 作った直後 |
| fulfilled(成功) | 処理が成功して、結果の値がある | resolve(値) が呼ばれたとき |
| rejected(失敗) | 処理が失敗して、失敗の理由がある | reject(理由) が呼ばれたとき |
成功か失敗に決まった状態を「settled(決着した)」と呼びます。
resolve で成功を知らせる Promise を作る
new Promise に渡す関数は、resolve(成功を知らせる関数)と reject(失敗を知らせる関数)を受け取ります。指定したミリ秒だけ待つ wait 関数を作り、この記事ではこれを通信の代わりに使います。
function wait(ms) {
return new Promise((resolve) => {
setTimeout(() => resolve(`${ms} ミリ秒待った`), ms);
});
}
const p = wait(1000);
console.log(p);
p.then((message) => {
console.log(message);
console.log(p);
});
最初の console.log(p) では Promise オブジェクトが表示され、左の ▶ で開くと [[PromiseState]]: "pending" です。1 秒後に then に渡した関数が呼ばれて「1000 ミリ秒待った」と表示され、このときの p は [[PromiseState]]: "fulfilled"、[[PromiseResult]]: "1000 ミリ秒待った" に変わっています。resolve に渡した値が、then の関数の引数として届くわけです。
reject で失敗を知らせ、catch・finally で受け取る
0 で割ろうとしたら失敗する、割り算の Promise を作ります。
function divide(a, b) {
return new Promise((resolve, reject) => {
setTimeout(() => {
if (b === 0) {
reject(new Error("0 では割れません"));
} else {
resolve(a / b);
}
}, 500);
});
}
divide(10, 2)
.then((result) => console.log("結果:", result))
.catch((error) => console.log("エラー:", error.message))
.finally(() => console.log("1 回目おわり"));
divide(10, 0)
.then((result) => console.log("結果:", result))
.catch((error) => console.log("エラー:", error.message))
.finally(() => console.log("2 回目おわり"));
結果: 5
1 回目おわり
エラー: 0 では割れません
2 回目おわり
| メソッド | 呼ばれるとき |
|---|---|
then(関数) | 成功したとき(結果の値を受け取る) |
catch(関数) | 失敗したとき(理由を受け取る) |
finally(関数) | 成功でも失敗でも最後に(「読み込み中」の表示を消すなど) |
reject には new Error("…") を渡すのが一般的です。error.message でメッセージを取り出せます。
then をつなげて、コールバック地獄を平らにする
then は新しい Promise を返すので、.then().then() とつなげられます(メソッドチェーン)。then の関数の中で Promise を return すると、次の then はその Promise が終わるまで待ちます。先ほどのコールバック地獄を書き直すと、右にずれなくなります。
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
wait(1000)
.then(() => {
console.log("ユーザー情報を取得");
return wait(1000);
})
.then(() => {
console.log("注文履歴を取得");
return wait(1000);
})
.then(() => {
console.log("おすすめ商品を取得");
});
結果はコールバック版と同じく、1 秒ごとに「ユーザー情報を取得」「注文履歴を取得」「おすすめ商品を取得」と表示されます(実測 1.01 秒・2.01 秒・3.02 秒)。
async/await:Promise を普通のコードのように書く
async と await を使うと、Promise を使った処理を上から順に実行される普通のコードのように書けます。
async function:関数の前にasyncを付けると、その関数は必ず Promise を返すようになります。returnした値は、その Promise の結果になります。await:Promise の前に付けると、その Promise が決着するまでこの関数の続きだけを止めて待ち、結果の値を取り出します。待っている間、ほかの処理(画面の操作など)は止まりません。
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function main() {
await wait(1000);
console.log("ユーザー情報を取得");
await wait(1000);
console.log("注文履歴を取得");
await wait(1000);
console.log("おすすめ商品を取得");
return "完了";
}
const result = main();
console.log(result);
result.then((value) => console.log("main の戻り値:", value));
ユーザー情報を取得
注文履歴を取得
おすすめ商品を取得
main の戻り値: 完了
この 4 行の前に、console.log(result) による Promise が 1 行表示されます(▶ で開くと [[PromiseState]]: "pending")。呼んだ直後の result は「完了」ではなく pending の Promise で、3 秒後に return "完了" まで進むと「完了」で成功し、then に届きます。async 関数は値を Promise に包んで返すことは、あとの「よくある間違い」につながる大事な点です。
なお、await は基本的に async 関数の中でしか使えません(例外はモジュール形式のスクリプトのいちばん外側)。ただし Chrome や Edge のコンソールは特別で、Chrome 62 から async 関数の外でも await を書けるようになっています(Chrome の公式ブログ「New in Chrome DevTools 62」)。
エラー処理は try/catch で書く
await した Promise が失敗(rejected)すると、await の行で例外が投げられます。そのため、普通の例外と同じように try/catch/finally で受け止められます。また、async 関数の中で throw すると、その関数が返す Promise が失敗になります。
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function getUser(id) {
await wait(500);
if (id !== 1) {
throw new Error(`ID ${id} のユーザーは見つかりません`);
}
return { id: 1, name: "山田" };
}
async function showUser(id) {
try {
const user = await getUser(id);
console.log("名前:", user.name);
} catch (error) {
console.log("エラー:", error.message);
} finally {
console.log(`ID ${id} の処理おわり`);
}
}
async function main() {
await showUser(1);
await showUser(2);
}
main();
名前: 山田
ID 1 の処理おわり
エラー: ID 2 のユーザーは見つかりません
ID 2 の処理おわり
then/catch/finally と、try/catch/finally が、それぞれ対応していることが分かります。
await を順番に書くと遅い:Promise.all で同時に待つ
3 つのデータ(A は 1 秒、B は 2 秒、C は 1 秒かかる)を取得する、お互いに関係のない処理を考えます。前半は await を 1 つずつ順番に書き、後半は Promise.all でまとめて待ちます。
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function download(name, ms) {
console.log(`${name} 開始`);
await wait(ms);
console.log(`${name} 終了`);
return `${name} のデータ`;
}
async function main() {
let start = performance.now();
await download("A", 1000);
await download("B", 2000);
await download("C", 1000);
console.log(`順番に await:${((performance.now() - start) / 1000).toFixed(2)} 秒`);
start = performance.now();
const results = await Promise.all([
download("A", 1000),
download("B", 2000),
download("C", 1000),
]);
console.log(results);
console.log(`Promise.all:${((performance.now() - start) / 1000).toFixed(2)} 秒`);
}
main();
A 開始
A 終了
B 開始
B 終了
C 開始
C 終了
順番に await:4.03 秒
A 開始
B 開始
C 開始
A 終了
C 終了
B 終了
['A のデータ', 'B のデータ', 'C のデータ']
Promise.all:2.00 秒
順番に await すると、A が終わってから B、B が終わってから C を始めるので、1 + 2 + 1 で約 4 秒かかりました。Promise.all では A・B・C が続けて「開始」し、1 秒後に A と C、2 秒後に B が終わって、合計は一番長い B とほぼ同じ 2 秒です。終わった順番は A・C・B ですが、results の配列は渡した順(A・B・C)に並んでいます。MDN にも「結果の配列は、完了した順ではなく、渡した Promise の順になる」と書かれています。

ポイントは、download("A", 1000) を呼んだ時点で処理が始まることです。Promise.all は、すでに始まっている 3 つの Promise が全部終わるのを待つだけです。一方、B の処理に A の結果が必要なとき(ログインしてからデータを取得するなど)は、順番に await するのが正解です。
1 つでも失敗すると、Promise.all 全体が失敗する
A・B・C のうち C だけが 0.5 秒後に失敗するようにして Promise.all を try/catch で待つと、0.5 秒の時点ですぐに catch に入り、A と B の結果は受け取れませんでした。そのあとも A と B の「終了」のログは 1 秒後・2 秒後に表示されます。MDN にあるとおり、Promise.all が失敗しても残りの処理は取り消されず、最後まで動き続けます。
Promise.allSettled・race・any の違い
待ち方の違う仲間のメソッドです。A(1 秒・成功)、B(2 秒・成功)、C(0.5 秒・失敗)を渡して試した結果も並べます。
| メソッド | MDN の説明(要約) | A・B・C を渡した結果 |
|---|---|---|
Promise.all | 全部成功したら成功。1 つでも失敗したら失敗 | 0.5 秒で失敗(C の理由) |
Promise.allSettled | 全部が決着したら成功(成功・失敗の一覧を返す) | 2 秒で成功(A・B 成功、C 失敗の一覧) |
Promise.race | 最初に決着したものと同じ結果になる | 0.5 秒で失敗(C の理由) |
Promise.any | 最初に成功したものの結果。全部失敗したら失敗 | 1 秒で成功(A のデータ) |
一部が失敗しても残りの結果を使いたいときは allSettled が便利です。結果の配列の各要素は、status が "fulfilled" なら value に値が、"rejected" なら reason に失敗の理由が入っています。race は、3 秒かかる処理と「1 秒後に reject する Promise」を競争させて、制限時間を過ぎたら失敗にする(タイムアウト)使い方がよく知られています。この場合も、遅い処理そのものは止まらずに裏で動き続けます。
実際の通信(fetch)で使うときの形
Web API からデータを取得する fetch 関数も Promise を返すので、wait の代わりに await すれば同じ考え方で書けます。次は形だけを示した例です(URL は架空で、この記事では実行していません)。
async function getItems() {
try {
const response = await fetch("https://api.example.com/items");
if (!response.ok) {
throw new Error(`HTTP エラー:${response.status}`);
}
const data = await response.json();
console.log(data);
} catch (error) {
console.log("取得に失敗:", error.message);
}
}
気を付けたいのは、MDN に書かれているとおり、fetch の Promise は 404 や 500 などのエラーのステータスコードでは失敗(reject)にならないことです。失敗になるのは通信そのものができなかったときだけなので、上のように response.ok(ステータスコードが 200〜299 なら true)を自分で確かめます。
Web API の仕組みとステータスコードは「REST API とは?」で、ほかのサイトの API を呼んだときのエラーは「CORS とは?」で解説しています。受け取った JSON が読みにくいときは「JSON 整形ツール」で整えられます。
よくある間違い
1. await を付け忘れて、Promise が返ってくる
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function getUser() {
await wait(500);
return { id: 1, name: "山田" };
}
async function main() {
const user = getUser(); // await を忘れた
console.log(user);
console.log(user.name);
}
main();
1 行目には中身が pending の Promise が、2 行目には undefined が表示されます。async 関数は Promise を返すので、user はユーザー情報ではなく Promise で、name はありません。エラーにならずに進むので気付きにくい間違いです。const user = await getUser(); と直すと、「山田」が表示されます。
then でも同じような間違いがあります。then の中で wait(1000) を呼んでも return を忘れると、次の then は待たずに進みます(試すと、2 秒後のつもりの処理が約 1 秒後に動きました)。
2. forEach の中の await は待ってくれない
配列の要素を 1 つずつ非同期で処理しようとして、forEach に async 関数を渡すと、思ったとおりに動きません。
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function main() {
const ids = [1, 2, 3];
ids.forEach(async (id) => {
await wait(1000);
console.log(`${id} 番を処理した`);
});
console.log("すべて終わった?");
}
main();
すべて終わった?
1 番を処理した
2 番を処理した
3 番を処理した
「すべて終わった?」が真っ先に表示され、1 秒後に 3 行がまとめて表示されました。MDN にも「forEach() は同期的な関数を想定していて、Promise を待たない」と書かれています。forEach は async 関数を呼び出したら、返ってきた Promise を待たずに次の要素へ進んでしまうのです。
1 つずつ順番に処理したいときは、for...of 文を使います。
function wait(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
async function main() {
const ids = [1, 2, 3];
for (const id of ids) {
await wait(1000);
console.log(`${id} 番を処理した`);
}
console.log("すべて終わった");
}
main();
1 番を処理した
2 番を処理した
3 番を処理した
すべて終わった
1 秒ごとに 1 行ずつ表示され、「すべて終わった」が最後に来ます。順番どおりでなくてよく、まとめて速く終わらせたいときは、await Promise.all(ids.map(async (id) => { … })); のように、map で Promise の配列を作って Promise.all で待ちます。同じ 3 件が約 1 秒で終わり、そのあとに「すべて終わった」が表示されます。
3. 失敗を受け止めずに「Uncaught (in promise)」が出る
失敗した Promise を catch も try/catch もせずに放っておくと、コンソールに赤いエラーが表示されます。
async function load() {
throw new Error("読み込みに失敗");
}
load();
Uncaught (in promise) Error: 読み込みに失敗
at load (<anonymous>:2:9)
at <anonymous>:5:1
「Uncaught (in promise)」は「Promise の失敗が誰にも受け止められなかった」という意味です。普通の例外と違って、ここでプログラム全体が止まるわけではないため、エラーに気付かないまま画面が「読み込み中」のまま固まる、といった不具合の原因になります。async 関数を呼ぶ側で try/catch するか、load().catch((error) => …) のように catch を付けて、必ず失敗を受け止めましょう。
4. async 関数の外で await を書いて SyntaxError になる
コンソールでは async 関数の外でも await が使えますが、同じコードを普通の <script> や .js ファイルに書くと、次のエラーになります(Edge 155 で確認したメッセージです)。
SyntaxError: await is only valid in async functions and the top level bodies of modules
await は async 関数の中か、モジュール(<script type="module">)のいちばん外側でしか使えません。この記事の例のように、async function main() { … } の中に書いて main(); で呼ぶのが確実です。
よくある質問
then と async/await は、どちらを使えばよいですか?
新しく書くコードは、上から順に読めて try/catch も使える async/await がおすすめです。ただし async/await は Promise の上に作られた書き方なので、Promise.all を使うときや then で書かれた既存のコードを読むために、Promise の仕組みも知っておきましょう。
Python の async/await と同じものですか?
考え方(待ち時間を重ねる、await で結果を待つ)はよく似ています。大きな違いは、Python では asyncio.run() で動かす仕組みを自分で始める必要があるのに対し、ブラウザの JavaScript では最初から動いている点です。Python 版は「Python の asyncio 入門」で解説しています。
まとめ
- JavaScript は 1 本の流れで動き、待ち時間の間は止まらずに次のコードへ進む
- Promise は「あとで結果を渡す約束」。
resolveで成功、rejectで失敗を知らせ、then・catch・finallyで受け取る - async 関数は必ず Promise を返す。
awaitで結果を取り出し、失敗はtry/catchで受け止める - 独立した処理は
Promise.allで同時に待つ(実測 4.03 秒 → 2.00 秒) forEachの中の await は待たない。順番ならfor...of、まとめてならPromise.allとmap
関連する記事・ツール
- JavaScriptとは?できること・歴史・Javaとの違いと、ブラウザで今すぐ試す方法
- JavaScriptの配列メソッド入門|map・filter・reduceとsortの注意点
- Pythonのasyncio入門|async・awaitの基本と同時に待つ方法
- REST APIとは?HTTPメソッド・ステータスコードの意味とcurlでの試し方
- CORSとは?エラーの原因と正しい設定を2つのローカルサーバーで確かめる
- JSON整形ツール
- JavaScriptのfetchでAPIを呼ぶ|POST・エラー処理・タイムアウト