【JavaScript】Promiseの基本を完全理解!resolve / reject の仕組みとエラー処理

JavaScriptでAPI通信やタイマー処理、画像の読み込みといった「完了するまでに時間がかかる処理(非同期処理)」を扱う際に欠かせないのが Promise(プロミス) です。

async / await と組み合わせて何気なく使っている方も多いかもしれませんが、「resolve は使ったことがあるけれど、reject はいつどう使うの?」「エラーが起きた時はどうやって処理を切り替えればいいの?」と疑問に思うことはありませんか?

今回は、Promise の基本的な仕組み(3つの状態)や resolve / reject による成功・失敗の振り分け方、頻出する活用パターンまで、動きがひと目でわかるインタラクティブデモと一緒に分かりやすく解説します!

デモ動作

See the Pen Promiseの基本!resolve / reject の仕組みとエラー処理 by mikanbako (@mikanbako) on CodePen.

全画面でのデモ動作は以下のリンクからご確認下さい!(別タブで開かれます)

実装コード紹介

【HTML】

<div class="l-wrap">
  <h2>JavaScript Promise 動作体験デモ</h2>
  <p class="p-desc">ボタンを押して、Promiseの「状態変化(成功・失敗)」と「Promise.allの実用ワザ」を確認しよう!</p>
  
  <div class="p-demo-box">
    
    <!-- 💡 デモ1:resolve(成功)と reject(失敗)の仕組み -->
    <section class="p-section">
      <h3 class="c-sec-title">① 基本:resolve(成功)と reject(失敗)の分岐とエラー処理</h3>
      <p class="c-sec-desc">1秒間の非同期処理を実行し、結果に応じて <code>try...catch...finally</code> のどこを通るか確認します。</p>
      
      <!-- 現在のPromise状態バッジ -->
      <div class="c-state-bar">
        <span>現在の状態:</span>
        <span class="c-badge js-state-badge">待機前 (Idle)</span>
      </div>

      <!-- 結果表示ボックス -->
      <div class="c-result-box js-result-box">
        下のボタンを押して非同期処理をスタートしてね!
      </div>

      <!-- finally(共通後処理)のログ -->
      <div class="c-finally-log js-finally-log">
        💡 finally処理:まだ実行されていません
      </div>

      <div class="c-btn-group">
        <button class="c-btn c-btn--success js-btn-resolve" type="button">
          ⭕ 成功させる (resolveを実行)
        </button>
        <button class="c-btn c-btn--error js-btn-reject" type="button">
          ❌ 失敗させる (rejectを実行)
        </button>
      </div>
    </section>

    <!-- 💡 デモ2:Promise.all で最低待機時間を保証する -->
    <section class="p-section">
      <h3 class="c-sec-title">② 応用:Promise.all で「最低1秒の待機時間」を保証する</h3>
      <p class="c-sec-desc">処理自体は「0.2秒」で終わる場合、そのまま表示するとローディングが一瞬で消えて画面がチラつきます。</p>
      
      <div class="c-loader-stage js-loader-stage">
        <div class="c-spinner js-spinner"></div>
        <div class="c-loader-text js-loader-text">ボタンを押してローディングを比較!</div>
      </div>

      <div class="c-btn-group">
        <button class="c-btn c-btn--sub js-btn-fast" type="button">
          ⚡ 処理のみ待つ (0.2秒で終了)<br><small>※一瞬すぎて画面がチラつく</small>
        </button>
        <button class="c-btn c-btn--primary js-btn-all" type="button">
          ✨ Promise.all で最低1秒待つ<br><small>※両方終わるまで綺麗に待機!</small>
        </button>
      </div>
    </section>

  </div>
</div>

【CSS】

/* ベース装飾 */
.l-wrap {
  padding: 30px 15px;
  max-width: 650px;
  margin: 0 auto;
  color: #3e3e3e;
  text-align: center;
}

h2 {
  margin-bottom: 10px;
  font-size: 16px;
  color: #1bb4d4;
}

.p-desc {
  margin-bottom: 25px;
  font-size: 16px;
  font-weight: bold;
  color: #666;
  line-height: 1.6;
}

.p-demo-box {
  display: flex;
  flex-direction: column;
  gap: 30px;
  padding: 30px;
  text-align: left;
  background: #fff;
  border-radius: 12px;
  box-shadow: 0 4px 15px rgb(0 0 0 / 5%);
}

/* セクション共通 */
.p-section {
  padding: 20px;
  background: #f8f9fa;
  border: 1px solid #e9ecef;
  border-radius: 8px;
}

.c-sec-title {
  padding-left: 10px;
  margin-bottom: 6px;
  font-size: 16px;
  color: #1bb4d4;
  border-left: 4px solid #1bb4d4;
}

.c-sec-desc {
  margin-bottom: 15px;
  font-size: 13px;
  color: #666;
  line-height: 1.4;
}

.c-sec-desc code {
  padding: 2px 6px;
  font-size: 13px;
  font-weight: bold;
  color: #e83e8c;
  background: #e9ecef;
  border-radius: 4px;
}

/* デモ1:状態バーと結果表示 */
.c-state-bar {
  display: flex;
  gap: 10px;
  align-items: center;
  margin-bottom: 12px;
  font-size: 14px;
  font-weight: bold;
}

.c-badge {
  padding: 4px 12px;
  font-size: 13px;
  color: #fff;
  background: #6c757d;
  border-radius: 20px;
  transition: 0.2s;
}

.c-badge.is-pending {
  color: #333;
  background: #ffc107;
}

.c-badge.is-fulfilled {
  background: #28a745;
}

.c-badge.is-rejected {
  background: #dc3545;
}

.c-result-box {
  padding: 18px;
  margin-bottom: 10px;
  font-size: 16px;
  font-weight: bold;
  color: #555;
  text-align: center;
  background: #fff;
  border: 2px dashed #ccc;
  border-radius: 8px;
  transition: 0.2s;
}

.c-result-box.is-pending {
  color: #b8860b;
  background: #fffdf5;
  border-color: #ffc107;
}

.c-result-box.is-success {
  color: #28a745;
  background: #f0fff4;
  border-color: #28a745;
  border-style: solid;
}

.c-result-box.is-error {
  color: #dc3545;
  background: #fff5f5;
  border-color: #dc3545;
  border-style: solid;
}

.c-finally-log {
  padding: 8px 12px;
  margin-bottom: 15px;
  font-size: 13px;
  font-weight: bold;
  color: #666;
  background: #e9ecef;
  border-radius: 6px;
}

/* デモ2:ローディングステージ */
.c-loader-stage {
  display: flex;
  gap: 12px;
  align-items: center;
  justify-content: center;
  height: 90px;
  margin-bottom: 15px;
  font-size: 16px;
  font-weight: bold;
  color: #555;
  background: #fff;
  border: 2px solid #dee2e6;
  border-radius: 8px;
}

.c-spinner {
  display: none;
  width: 24px;
  height: 24px;
  border: 3px solid #e0f7fa;
  border-top-color: #1bb4d4;
  border-radius: 50%;
  animation: spin 0.8s linear infinite;
}

.c-spinner.is-active {
  display: block;
}

@keyframes spin {
  to {
    transform: rotate(360deg);
  }
}

/* ボタングループ */
.c-btn-group {
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: 10px;
}

.c-btn {
  padding: 12px 10px;
  font-family: inherit;
  font-size: 13px;
  font-weight: bold;
  line-height: 1.4;
  color: #fff;
  cursor: pointer;
  border: none;
  border-radius: 6px;
  transition: 0.2s;
}

.c-btn small {
  font-size: 12px;
  font-weight: normal;
  opacity: 0.9;
}

.c-btn:hover:not(:disabled) {
  opacity: 0.85;
  transform: translateY(-2px);
}

.c-btn:disabled {
  cursor: not-allowed;
  opacity: 0.5;
}

.c-btn--success {
  background: #28a745;
}

.c-btn--error {
  background: #e83e8c;
}

.c-btn--sub {
  background: #6c757d;
}

.c-btn--primary {
  background: #1bb4d4;
}

【JavaScript】

// =========================================
// 💡 デモ1:resolve(成功)と reject(失敗)の体験
// =========================================
const stateBadge = document.querySelector('.js-state-badge');
const resultBox = document.querySelector('.js-result-box');
const finallyLog = document.querySelector('.js-finally-log');
const btnResolve = document.querySelector('.js-btn-resolve');
const btnReject = document.querySelector('.js-btn-reject');

// Promiseを返す関数(引数 shouldSucceed が true なら成功、false なら失敗させる)
const fetchSampleData = (shouldSucceed) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldSucceed) {
        // ⭕ 成功時:resolve() を呼んで結果データを渡す
        resolve('🎉 データの取得に成功しました!(resolve)');
      } else {
        // ❌ 失敗時:reject() を呼んでエラー理由を渡す
        reject(new Error('⚠️ 通信エラーが発生しました!(reject)'));
      }
    }, 1000);
  });
};

// ボタンクリック時に async / await と try...catch で実行する関数
const runDemo1 = async (shouldSucceed) => {
  // 1. 処理開始時(Pending状態)の表示更新
  btnResolve.disabled = true;
  btnReject.disabled = true;
  stateBadge.textContent = '⏳ 処理中 (Pending)';
  stateBadge.className = 'c-badge is-pending';
  resultBox.textContent = 'サーバーと通信しています(1秒待機中)...';
  resultBox.className = 'c-result-box is-pending';
  finallyLog.textContent = '💡 finally処理:完了を待っています...';

  try {
    // 2. Promiseの完了を待つ(resolve されれば次の行へ進む!)
    const message = await fetchSampleData(shouldSucceed);
    
    stateBadge.textContent = '⭕ 成功 (Fulfilled)';
    stateBadge.className = 'c-badge is-fulfilled';
    resultBox.textContent = `【tryブロック実行】${message}`;
    resultBox.className = 'c-result-box is-success';

  } catch (error) {
    // 3. reject された場合は、自動的にこの catch ブロックへジャンプする!
    stateBadge.textContent = '❌ 失敗 (Rejected)';
    stateBadge.className = 'c-badge is-rejected';
    resultBox.textContent = `【catchブロック実行】${error.message}`;
    resultBox.className = 'c-result-box is-error';

  } finally {
    // 4. 成功しても失敗しても、最後に必ず実行される共通の後片付け処理!
    finallyLog.textContent = '💡 finally処理:通信終了につき、ボタンのロックを解除しました!';
    btnResolve.disabled = false;
    btnReject.disabled = false;
  }
};

btnResolve.addEventListener('click', () => runDemo1(true));
btnReject.addEventListener('click', () => runDemo1(false));


// =========================================
// 💡 デモ2:Promise.all で最低待機時間を保証する
// =========================================
const spinner = document.querySelector('.js-spinner');
const loaderText = document.querySelector('.js-loader-text');
const btnFast = document.querySelector('.js-btn-fast');
const btnAll = document.querySelector('.js-btn-all');

// 指定ミリ秒だけ待機する汎用Promise関数
const waitTime = (ms) => new Promise(resolve => setTimeout(resolve, ms));

// 0.2秒(200ms)ですぐに終わるデータ取得処理のシミュレーション
const quickTask = () => new Promise(resolve => {
  setTimeout(() => resolve('データ読み込み完了!'), 200);
});

// パターンA:処理だけをそのまま待つ(0.2秒で終わってしまう)
btnFast.addEventListener('click', async () => {
  btnFast.disabled = true;
  btnAll.disabled = true;
  spinner.classList.add('is-active');
  loaderText.textContent = '読み込み中...';

  const result = await quickTask(); // 0.2秒で完了

  spinner.classList.remove('is-active');
  loaderText.textContent = `⚡ ${result}(0.2秒で終了・チラつきます)`;
  btnFast.disabled = false;
  btnAll.disabled = false;
});

// パターンB:Promise.all で「最低1秒の待機」と組み合わせる
btnAll.addEventListener('click', async () => {
  btnFast.disabled = true;
  btnAll.disabled = true;
  spinner.classList.add('is-active');
  loaderText.textContent = '読み込み中...';

  // 💡 0.2秒の処理と、1秒の待機タイマーを同時に走らせ、両方終わるまで待つ!
  const [result] = await Promise.all([
    quickTask(),
    waitTime(1000)
  ]);

  spinner.classList.remove('is-active');
  loaderText.textContent = `✨ ${result}(1秒経過後にスムーズに表示!)`;
  btnFast.disabled = false;
  btnAll.disabled = false;
});

Promiseの仕組みとエラーハンドリング・活用例

Promiseとは?(3つの状態と基本構文)

Promise は一言でいうと「今はまだ結果が出ていないけれど、将来的に『成功』か『失敗』のどちらかの結果を必ず返すと約束(Promise)してくれるオブジェクト」です。

Promiseは以下の3つの状態(ステータス)を持ちます。

  • pending(待機中)
    処理がまだ終わっていない初期状態。
  • fulfilled(成功)
    処理が無事に完了した状態(resolve() を呼ぶとこの状態になります)。
  • rejected(失敗)
    エラーなどで処理が失敗した状態(reject() を呼ぶとこの状態になります)。

【重要:Promiseを定義して呼び出す時の注意点】
new Promise() は書いた瞬間に中の処理がスタートしてしまう仕様になっています。そのため、後から好きなタイミングで await sampleFunction() のように関数として呼び出したい場合は、以下のように「new Promise を返す関数」として定義するのが鉄則です!

// ⭕ 関数の中に new Promise を入れて return する!
const sampleFunction = () => {
  return new Promise((resolve, reject) => {
    // 何かしらの時間のかかる処理...
    const isSuccess = true;

    if (isSuccess) {
      resolve('成功した時のデータ'); // 処理完了を通知!
    } else {
      reject(new Error('失敗した理由')); // エラー発生を通知!
    }
  });
};

// 使う時は関数として () をつけて呼び出し、await で完了を待つ
await sampleFunction();

reject(エラー)はどう扱う? try...catch...finally の書き方

成功時の resolve() だけでなく、通信失敗やタイムアウト時に reject() を呼ぶようにしておくと、呼び出し側で「正常な処理」と「エラー時の処理」を綺麗に切り分けることができます。

async / await を使う場合は、try...catch...finally 構文 で囲むのが基本です!

const initApp = async () => {
  try {
    // 1. resolve() が呼ばれれば、引数に渡したデータが返り値として受け取れる!
    const data = await sampleFunction();
    console.log('成功:', data);

  } catch (error) {
    // 2. reject() が呼ばれた瞬間、tryの残りの処理はスキップされ、ここにジャンプする!
    console.error('エラー発生:', error.message);
    alert('データの読み込みに失敗しました。再試行してください。');

  } finally {
    // 3. 成功しても失敗しても、最後に必ず実行される(ローディング画面を消す処理などに最適!)
    console.log('通信処理を終了します');
  }
};

※なお、async / await を使わずにメソッドチェーンで書く場合は、sampleFunction().then(成功時).catch(失敗時).finally(終了時) という書き方になります。

よく使われるPromiseの3大パターン

① 指定時間だけ処理を止める「待機(スリープ)関数」

setTimeout はそのままでは await で待てませんが、Promiseで包むことで「処理の途中で1秒待つ」といった記述がたった1行で書けるようになります!

// 指定ミリ秒だけ待つ関数(超頻出!)
const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// 使い方:アニメーションや処理の合間に好きな秒数だけ待機できる
await wait(1000); // 1秒待ってから次の行へ進む!

② Promise.all() を使った「最低待機時間」の保証

API通信やデータの準備があまりにも一瞬(0.1秒など)で終わってしまうと、ローディング画面が一瞬だけパッと表示されて消えるため、画面が激しくチラついて見えてしまいます。 そこで Promise.all([データ処理, 最低待機時間]) を使うと、「すべてのPromiseが完了するまで待つ」という性質を利用して、「処理が早く終わっても最低1.5秒間はローディングを見せる(逆に処理に2秒かかったら2秒待つ)」というUI制御が簡単に作れます!

await Promise.all([
  fetchData(), // 実際のデータ取得処理
  wait(1500)   // 最低でも1.5秒は待つタイマー
]);
// ↑ 両方が完了したタイミングで次の処理(例えばローディングを非表示にするなど)

③ 画像の読み込み完了を待つ処理

画像の onload(読み込み成功)に resolve、onerror(読み込み失敗)に reject を設定することで、画像のロード完了を await で確実に待ってからアニメーションを開始するといった制御にもよく使われます。

補足:公式ドキュメント

・MDN: Promise

まとめ

今回はJavaScriptの非同期処理の土台となる Promise について解説しました。

  • resolve() は処理の成功を通知し、reject() はエラー(失敗)を通知する
  • エラーを受け取る時は try...catch で囲み、共通の後片付け(ローディング解除など)は finally に書く
  • 複数の非同期処理を同時に走らせてすべて終わるのを待つなら Promise.all() が活躍する

普段使っている fetch() などの非同期メソッドも、裏側ではすべてこの Promise を返しています。自分で new Promise を組み立てられるようになると、タイマー待機やローディング制御の幅が広がるので、ぜひ活用してみてください!

Prev
Next