---
type: reference
language: javascript
slug: promise/promise
title: "Promise — then / catch / finally と async / await"
title_tag: "JavaScript Promise の使い方 — then と async/await の関係"
summary: >
  Promise は「あとで決まる値」を表します。3つの状態、then の繋がり方、途中で投げたときの流れ、
  async 関数が必ず Promise を返すこと、同期処理より後回しになる順序までを実行して確かめます。
description: >
  then の中で投げると次の then は飛ばされ、catch まで届きます。async 関数が必ず Promise を
  返すこと、同期処理より必ず後になる実行順序まで、順番を出力して確かめられます。
status: published
difficulty: 3
minutes: 10

versions:
  verified: "Node 24.22.3"
  since: "ES2015"
  deprecated: null
  removed: null

sources:
  - title: "Promise Objects — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-promise-objects"
  - title: "Async Function Definitions — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-async-function-definitions"
  - title: "Promise — MDN"
    url: "https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Promise"

terms: [Promise, マイクロタスク, 拒否, 非同期関数]

links:
  related:
    - javascript/errors/await-is-only-valid-in-async
    - javascript/reference/timer/set-timeout
    - javascript/how-to/async/parallel
    - javascript/errors/is-not-a-function
    - javascript/reference/array/map
    - javascript/how-to/async/retry

content_updated_at: 2026-09-08
published_at: 2026-09-08
---

`Promise` は、**いまはまだ決まっていない値**を表す入れ物です。
通信や読み込みのように、結果が出るまで待つものを扱います。

```js run
const value = Promise.resolve(1);

console.log(value instanceof Promise);
console.log(await value);
```
```output
true
1
```

## 3つの状態

| 状態 | 意味 | 決まり方 |
|---|---|---|
| pending | まだ決まっていない | 最初はこれ |
| fulfilled | [key:値が決まった] | `resolve(値)` |
| rejected | [bad:失敗が決まった] | `reject(理由)` / 例外 |

**一度決まったら変わりません。** 決まったあとに `resolve` を呼んでも何も起きません。

## 繋げる

`then()` は[key:新しい Promise を返す]ので、繋げられます。

```js run
const result = await Promise.resolve(1)
  .then((n) => n + 1)
  .then((n) => n * 10);

console.log(result);
```
```output
20
```

`then()` の中で返した値が、次の `then()` に渡ります。
**返さないと `undefined` が流れます。**

```js run
console.log(await Promise.resolve(1).then(() => {}));
```
```output
undefined
```

`map()` で `return` を忘れたときと同じ形の間違いです。
→ [Array.prototype.map()](/ja/javascript/reference/array/map/)

## 失敗したとき

```js run
const order = [];

await Promise.reject(new Error('だめ'))
  .then(() => order.push('then'))
  .catch((error) => order.push('catch:' + error.message))
  .finally(() => order.push('finally'));

console.log(order);
```
```output
[ 'catch:だめ', 'finally' ]
```

**`then` は飛ばされます。** 失敗したときは `catch` まで一気に進みます。
`finally` は成否に関係なく必ず通ります。

途中で例外を投げても同じです。

```js run
const out = await Promise.resolve(1)
  .then(() => {
    throw new Error('途中で失敗');
  })
  .then(() => 'ここは通らない')
  .catch((error) => 'catch: ' + error.message);

console.log(out);
```
```output
catch: 途中で失敗
```

[em:例外は、後ろの `catch` に向かって落ちていきます。]
`try` / `catch` と同じ考え方です。

## `async` 関数は必ず `Promise` を返す

```js run
const load = async () => 1;

console.log(load() instanceof Promise);
console.log(await load());
```
```output
true
1
```

`1` を返すと書いても、返るのは[key:`1` を包んだ Promise]です。
**`await` を付けないと中身が取れません。**

投げた場合も、例外がそのまま飛ぶのではなく[bad:拒否された Promise]になります。

```js run
const fail = async () => {
  throw new Error('投げた');
};

try {
  await fail();
} catch (error) {
  console.log('捕まえた:', error.message);
}
```
```output
捕まえた: 投げた
```

`await` していない `async` 関数の中で投げると、**誰も受け取らないまま残ります。**
呼びっぱなしにしないでください。

## 同期処理より必ず後になる

```js run
const log = [];

log.push('1 同期');
Promise.resolve().then(() => log.push('3 マイクロタスク'));
log.push('2 同期');

await Promise.resolve();

console.log(log);
```
```output
[ '1 同期', '2 同期', '3 マイクロタスク' ]
```

`Promise.resolve()` は**すでに決まっている**のに、`then` の中身は後から動きます。

決まった `Promise` の続きは[type:マイクロタスク]という待ち行列に積まれ、
**いま動いているコードが最後まで終わってから**実行されるからです。

**「もう値はあるのだから、すぐ動くはず」は成り立ちません。**

## `then` と `await` の使い分け

同じことができます。読みやすいほうを選んでください。

```js run
const load = async (n) => n * 2;

console.log(await load(1).then((n) => n + 1));

const value = await load(1);
console.log(value + 1);
```
```output
3
3
```

- **順番に待つだけ** … `await` のほうが読みやすい
- **同時に走らせる** … `Promise.all()` を使う
- **繋いだ処理を関数として組み立てる** … `then` が向く

→ [複数の非同期処理を同時に走らせる](/ja/javascript/how-to/async/parallel/)

## よくある間違い

### `await` を付け忘れる

```js bad
const load = async () => 1;

const value = load();

console.log(value instanceof Promise);
console.log(value + 1);
```
```output
true
[object Promise]1
```

**エラーになりません。** `Promise` そのものが変数に入り、
文字列として繋がれて `[object Promise]` になります。

画面に `[object Promise]` が出たら、[bad:`await` の付け忘れを疑ってください]。

### `catch` を付けずに放置する

失敗した `Promise` を誰も受け取らないと、**そのまま静かに残ります。**
`.catch()` を書くか、`try` / `catch` の中で `await` してください。

### `new Promise` で包み直す

```js bad
const wrong = () => new Promise((resolve) => resolve(fetchSomething()));
```

すでに `Promise` を返すものを、もう一度 `new Promise` で包む必要はありません。
`async` 関数の中で `await` するか、そのまま返してください。

**`new Promise` を書くのは、`Promise` でない仕組み**
（古い形のコールバック、`setTimeout` など）**を包むときだけ**です。

## まとめ

- `Promise` は「あとで決まる値」。状態は[num:3]つで、**一度決まったら変わらない**
- `then()` は新しい `Promise` を返す。**返さないと `undefined` が流れる**
- 失敗すると `then` を飛ばして `catch` へ。`finally` は必ず通る
- **`async` 関数は必ず `Promise` を返す。** 投げても拒否された `Promise` になる
- 決まっていても、続きは[type:マイクロタスク]。**同期処理より必ず後**
- `[object Promise]` が出たら `await` の付け忘れ
