fetchの結果が undefined — 非同期処理の基本

非同期処理の基本。コード画面と時計、後から届くデータの封筒。

roadmap.sh のどこをやっているか

Frontend/JavaScript›JavaScript
  • Fetch API と Ajax
  • Promise / async-await
  • エラー処理
  • CORS

この記事は、上の項目を実際に手を動かして確かめる回です。

前回: 単語カードを自力で作る — コードは1行も載せません 前回作った ~/web/ のファイルを、そのまま使います。作業はVMの中の Ubuntu、ブラウザはWindows側(ホスト)です。

前回で、ボタンを押すと画面が変わるところまで来ました。ただし、そこに出していたのは自分でコードに書いた文字だけです。

Webアプリらしくなるのは、データを外から取ってくるようになってからです。その入口が fetch です。

前回: HTML・CSS・JavaScriptで動く画面を作る演習|状態を1つ決めて組み立てる 前回作った ~/web/ のファイルを、そのまま使います。作業はVMの中の Ubuntu、ブラウザはWindows側(ホスト)です。

前回で、ボタンを押すと画面が変わるところまで来ました。ただし、そこに出していたのは自分でコードに書いた文字だけです。

そして、ここでほぼ全員が同じ壁にぶつかります。私も丸一日溶かしました。

let data;
fetch("/api").then(r => r.json()).then(j => { data = j; });
console.log(data);   // undefined

取ってきたはずのデータが undefined になります。

スペルミスもタイプミスもありません。fetch の行を消してみると壊れるので、動いてはいるようです。それでも console.log は undefined を出します。

このとき、私は「fetch の書き方が悪いんだろう」と思って、fetch の書き方だけを何十通りも試しました。ぜんぶ無駄でした。 原因は fetch ではなく、JavaScript が処理を進める順番そのものにあります。

この記事は、その「順番」の話です。ここを飛ばして async / await だけ覚えると、動くコードは書けても、壊れたときに直せません。

対象レベル: 初級 / 区分: 必修

目次

この記事でわかること

  • undefined になるのは書き方の間違いではない。 結果が来る前に次の行が実行されている
  • JavaScript は1本の線でしか動かない(シングルスレッド)。 だから「待つ」のではなく「予約して先に進む」
  • await は .then() の書き換えであって、別物ではない。 中で起きていることは同じ
  • fetch は404や500では例外にならない。 try / catch を書いても素通りする

この記事でやること

  1. VMの中に data.json を置き、外部APIを使わずに fetch を動かす
  2. console.log の順番がずれるのを見て、同期と非同期の違いを確認する
  3. .then() で書いたものを async / await に書き換える
  4. わざと404を踏んで、fetch が例外を投げないことを確認する
  5. 取ってきたデータで画面にリストを描き、読み込み中と失敗時の表示を付ける

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
非同期処理結果が返るまで待たずに次の行へ進み、結果が届いたときにあらためて処理するやり方。通信のように時間のかかるものはこれになる
JSON(JavaScript Object Notation)データをやりとりするための書き方。JavaScript のオブジェクトに似ているが、コメント・末尾のカンマ・シングルクォートは書けない
fetchJavaScript からサーバーにデータを取りに行く命令。結果はその場では返らない
Promise「まだ無い結果」を表す引換券。あとで成功したか失敗したかのどちらかが決まる
async / awaitPromise を、上から下に読める見た目で書くための書き方。新しい仕組みではなく書き換え
CORS(オリジン間リソース共有)「別の場所から取ってきたデータを JavaScript に渡してよいか」をブラウザが判断する仕組み。止められるとエラーになる

準備:VMの中にデータを置く

外部のAPIは使いません。理由は、ネットワークとCORSで詰まるからです。

学びたいのは非同期処理であって、他人のサーバーの都合ではありません。自分のVMの中だけで完結させます。

作業ディレクトリ

ここからはVMの中の Ubuntuです。VS Code から VM に接続して開いてもいいですし、ターミナルでもかまいません。

bash
$ cd ~/web
$ ls

前回までのファイルが並んでいるはずです。

index.html  script.js  style.css

data.json を作る

~/web/data.json を新しく作って、こう書きます。

{
  "updated": "2026-09-02",
  "items": [
    { "id": 1, "title": "HTMLを書く", "done": true },
    { "id": 2, "title": "CSSで整える", "done": true },
    { "id": 3, "title": "DOMを操作する", "done": true },
    { "id": 4, "title": "非同期処理を理解する", "done": false }
  ]
}

JSONにはコメントが書けませんし、末尾のカンマも許されません。JavaScript のオブジェクトと見た目が似ているので混同しやすいところです。

JSON でよくある構文エラー – 最後の要素の後ろにカンマを付けた("done": false }, のあとに ]) – キーをシングルクォートで囲んだ('id' は不可、必ずダブルクォート) – true を True と書いた(JSONは小文字だけ)

書けたら、VMの中で構文が正しいか確認できます。

bash
$ python3 -m json.tool ~/web/data.json

整形されて表示されれば正しいJSONです。エラーが出たら、その行番号を直してください。ブラウザで踏む前にここで潰しておくと、原因の切り分けが1段階減ります。

サーバーを立てる

VMの中で、これを実行します。

bash
$ cd ~/web
$ python3 -m http.server 8000 --bind 0.0.0.0

8000番は HTMLの回で ufw に開けてあります。 念のため sudo ufw status に 8000/tcp の行があるか見ておいてください。無ければ sudo ufw allow 8000/tcp です。

ホスト側(Windows)のブラウザから開きます。

http://192.168.226.50:8000/

IPは自分のVMのものに読み替えてください。 分からなくなったら、VMの中で ip a を実行して 192.168. から始まるアドレスを見ます。

http://192.168.226.50:8000/data.json を直接開いて、JSONがそのまま表示されることを先に確認しておいてください。ここが表示されないなら、この先は全部失敗します。

戻し方

この記事でやることは、すべて ~/web/ の中で完結します。

  • サーバーを止める → ターミナルで Ctrl + C
  • 元に戻す → 追加した data.json を消し、script.js を前回の内容に戻すだけ
  • VMの設定で触るのは ufw の 8001番だけです。CORSの実験のために一時的に開け、記事の最後で閉じます
bash
$ sudo ufw delete allow 8001/tcp   # ← 記事の最後にやる

念のため、始める前にコピーを取っておくと安心です。

bash
$ cp ~/web/script.js ~/web/script.js.bak

まず undefined を踏む

~/web/script.js の中身を、いったん全部これに置き換えます。

let data;

fetch("data.json")
  .then((res) => res.json())
  .then((json) => {
    data = json;
  });

console.log("ここで data は:", data);

ブラウザで http://192.168.226.50:8000/ を開き、F12 で開発者ツールを出して Console タブを見ます(開発者ツールの回でやった操作です)。

ここで data は: undefined

fetch は成功しているのに、undefined です。

本当に成功しているか、確かめてみます。.then の中にも console.log を足します。

let data;

fetch("data.json")
  .then((res) => res.json())
  .then((json) => {
    data = json;
    console.log("B: 中では入っている", data);
  });

console.log("A: 外では入っていない", data);

Console にはこう出ます。

A: 外では入っていない undefined
B: 中では入っている {updated: '2026-09-02', items: Array(4)}

注目すべきは「Aが先に出ている」ことです。

コードの上では B のほうが上に書いてあります。それなのに、実行されたのは A が先でした。

[スクリーンショット: 01_undefined.png] Console に「A: 外では入っていない undefined」が先、「B: 中では入っている {…}」が後に出ている状態を撮ってください。書いた順と出た順が逆であることが分かるように、2行が両方入るようにします。

これが undefined の正体です。 データが取れていないのではありません。console.log のほうが先に走っただけです。

同期と非同期の違い

fetch を離れて、もっと短い例で確認します。Console に直接打ち込んでかまいません(ホスト側のブラウザの Console です)。

console.log("1");
setTimeout(() => console.log("2"), 0);
console.log("3");

出力はこうなります。

1
3
2

0 ミリ秒待てと書いたのに、2 が最後です。

ここが分かれ目でした。私は「0秒なら即実行だろう」と思っていたので、この結果が理解できませんでした。

setTimeout は「0ミリ秒後に実行する」命令ではありません。「0ミリ秒後に、順番待ちの列に並べる」命令です。

そして、列が処理されるのは、いま書いてある処理が全部終わったあとです。だから 3 より後になります。

同期(synchronous)非同期(asynchronous)
実行のされ方書いた順に、上から1行ずつ予約だけして先に進む
結果が返るのはその場後から
代表例console.log、計算、textContent の書き換えfetch、setTimeout、ファイル読み込み
戻り値結果そのもの結果ではなく「引換券」

「時間のかかる処理は、結果が後から来る」 ——この一行が、この記事の全部です。

なぜそうなるのか

JavaScript は1本の線でしか動かない

JavaScript が同時にできる仕事は、常に1つだけです。 これをシングルスレッドと言います。作業台が1つしかない、と思ってください。

もし fetch が「返事が来るまでその場で待つ」動きをしたら、どうなるでしょうか。

その間、作業台は塞がったままです。

  • ボタンを押しても反応しない
  • 文字を入力しても表示されない
  • スクロールも止まる

画面が完全に固まります。 サーバーの返事が3秒かかれば、3秒間フリーズします。

アプリを触っていて「固まった」と感じるとき、たいていはこの線が1本しかないところで、重い処理が居座っている状態です。

だから「終わったら呼んでね」と予約する

固まらせないために、JavaScript はこうします。

  1. fetch に「データ取ってきて」と頼むだけ頼む
  2. 返事を待たずに、次の行へ進む
  3. あとで返事が届いたら、登録しておいた処理を呼んでもらう

この「あとで呼んでもらう処理」が .then() の中身です。

待っているのではなく、予約しているだけです。 だから console.log は先に走ります。

[fetch を頼む] → [次の行へ] → [console.log 実行] → ……(数十ミリ秒後)…… → [返事が届く] → [.then の中が実行される]

この矢印の順番が頭に入れば、undefined は二度と謎ではなくなります。

コールバックで書くと深くなる

「終わったら呼んでね」と関数を渡す書き方をコールバックと言います。setTimeout に渡した関数も、.then() に渡した関数も、全部コールバックです。

問題は、順番に3回やりたいときです。

setTimeout(() => {
  console.log("1つ目 完了");
  setTimeout(() => {
    console.log("2つ目 完了");
    setTimeout(() => {
      console.log("3つ目 完了");
      setTimeout(() => {
        console.log("4つ目 完了");
      }, 500);
    }, 500);
  }, 500);
}, 500);

右へ右へと階段状に深くなっていきます。 これをコールバック地獄と呼びます。

実際に Console に貼って動かすと、0.5秒ごとに1行ずつ出ます。動きは正しいのですが、

  • どこでエラーが起きたのかを受け止める場所が、階段のどこにもない
  • 途中に処理を1つ挟むと、その下が全部インデントし直しになる
  • 読む順番が、上から下ではなく「内側へ内側へ」になる

動くけれど、手を入れられないコードになります。これを平らにするために出てきたのが、次の Promise です。

Promise ——まだ無い結果の引換券

fetch が返してくるものを、そのまま見てみます。Console に打ち込んでください。

const p = fetch("data.json");
console.log(p);
Promise {<pending>}

データではなく、Promise という別のものが返ってきます。

私はこれを、引換券だと理解しました。

ラーメン屋で食券を買うと、券が出てきます。券はラーメンではありません。 でも「あとでラーメンと交換できる」ことは保証されています。 Promise はこの券です。中身はまだ無いが、後で必ず「できた」か「無理だった」のどちらかになる、という約束です。

3つの状態

Promise は必ずこの3つのどれかです。

状態意味いつなるか
pending待機中。まだ結果が無い作られた直後
fulfilled成功。結果が入った処理がうまくいったとき
rejected失敗。理由が入った通信が切れた、URLが不正 など

そして、いったん fulfilled か rejected になったら、二度と変わりません。 一度決まった結果がひっくり返らないので、安心して受け取れます。

Console で状態が変わる様子が見られます。

const p = fetch("data.json");
console.log("直後:", p);
setTimeout(() => console.log("1秒後:", p), 1000);
直後: Promise {<pending>}
1秒後: Promise {<fulfilled>: Response}

[スクリーンショット: 02_promise状態.png] Console で Promise {<pending>} と Promise {<fulfilled>: Response} が並んで出ている状態を撮ってください。同じ変数なのに中身が変わっていることが分かるようにします。

.then() で受け取る

引換券から中身を取り出すのが .then() です。

fetch("data.json")
  .then((res) => res.json())
  .then((json) => console.log(json.items.length));

ここでなぜ .then() が2回いるのかが、最初の疑問でした。

行何が起きているか
fetch("data.json")通信の予約。ヘッダが返ってきた時点で解決する
.then((res) => res.json())res は応答そのもの(本文はまだ読んでいない)。res.json() で本文を読み始める——これも時間がかかるのでまた Promise が返る
.then((json) => ...)ここでようやくJavaScriptのオブジェクトが手に入る

res を console.log しても中身のデータは見えません。

fetch("data.json").then((res) => console.log(res));
// Response {type: 'basic', url: '...', status: 200, ok: true, ...}

ここに出ている status と ok は、あとで一番大事な話になります。覚えておいてください。

階段が平らになる

さっきのコールバック地獄を Promise で書き直すと、こうなります。

const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

wait(500)
  .then(() => { console.log("1つ目 完了"); return wait(500); })
  .then(() => { console.log("2つ目 完了"); return wait(500); })
  .then(() => { console.log("3つ目 完了"); return wait(500); })
  .then(() => { console.log("4つ目 完了"); })
  .catch((err) => console.error("どこかで失敗:", err));

深くなりません。上から下に読めます。

ポイントは return wait(500) です。.then() の中で Promise を返すと、次の .then() はそれが終わるまで待ってくれます。 これを忘れて return を書かないと、全部いっぺんに走ります。

そして最後の .catch() は、上のどこで失敗しても受け止めます。 階段の内側に受け止め役を4つ書く必要がありません。

new Promise(...) を自分で書くのは、こういう「元々コールバックだったもの」を包むときだけです。 fetch はもう Promise を返すので、わざわざ new Promise で包み直してはいけません(アンチパターンとして有名です)。

async / await —— .then() の書き換え

ここまでの .then() が理解できていれば、async / await は新しい概念ではありません。

await は .then() の書き換えです。裏で起きていることは同じです。

// .then() で書いたもの
function load() {
  return fetch("data.json")
    .then((res) => res.json())
    .then((json) => {
      console.log(json.items.length);
      return json;
    });
}

// await で書いたもの(やっていることは同じ)
async function load() {
  const res = await fetch("data.json");
  const json = await res.json();
  console.log(json.items.length);
  return json;
}

下のほうが、同期のコードとほぼ同じ見た目になります。 これが await の唯一にして最大の利点です。

.then()await
p.then(v => ...)const v = await p;
.catch(e => ...)try { } catch (e) { }
.finally(() => ...)finally { }
前の .then が return した値が次に渡るそのまま変数に入る

await は async の中でしか使えない

これが最初のエラーです。 Console でこう打ってみてください。

const res = await fetch("data.json");

Console では動いてしまうことがありますが、script.js に同じことを書くとエラーになります。

Uncaught SyntaxError: await is only valid in async functions and the top level bodies of modules

await を使う関数には、必ず async を付けます。

async function load() {
  const res = await fetch("data.json");   // OK
}

なぜ async が要るのか。 async は「この関数は途中で中断して、あとで再開することがあります」という宣言です。 印が無いと、JavaScript は「この関数は最後まで一気に走る」前提でコードを読みます。だから先に宣言しておく必要があります。

async を付けた関数は Promise を返す

ここも引っかかりました。

async function load() {
  return 42;
}

console.log(load());        // Promise {<fulfilled>: 42}
console.log(await load());  // 42

async を付けた時点で、戻り値は必ず Promise に包まれます。 中で return 42 と書いても、外から見れば「42 が入った引換券」です。

だから、async 関数を呼ぶ側も await するか .then() するかしないと、値は取れません。

// よくある間違い
const data = load();
console.log(data.items);          // undefined(エラーは出ない)
console.log(data.items.length);   // Uncaught TypeError: Cannot read properties of undefined

1行目でエラーは出ません。 data は Promise というオブジェクトで、そこに items が無いだけなので、undefined が静かに返ります。 JavaScriptの回で書いた「無いものを取ると undefined が返るだけ」がそのまま起きています。

エラーになるのは、その undefined をさらに触った瞬間です。前回の Cannot read properties of null と同じ形が、ここでも出ます。

これが厄介な理由は、エラーが出る場所と原因の場所がずれることです。await を忘れたのは1行目なのに、怒られるのは3行目です。

トップレベル await の注意

「関数の外でも await を使いたい」と思うはずです。使えますが、条件があります。

<script type="module" src="script.js"></script>

type="module" を付けたときだけ、ファイルの一番外側で await が書けます(トップレベル await)。付けていない普通の <script> では構文エラーです。

ただし type="module" には副作用があります。

type="module" を付けると、file:// で開いたときに読み込み自体が失敗します。 モジュールは必ずHTTP経由で読む必要があるためです。 今回はサーバーを立てているので問題ありませんが、「ダブルクリックでHTMLを開いたら動かない」の原因のひとつです。

この記事では、混乱を避けるため type="module" は使いません。 代わりに、async 関数を定義してその場で呼びます。

async function main() {
  const res = await fetch("data.json");
  const json = await res.json();
  console.log(json);
}

main();

main() を呼び忘れると何も起きません。 定義しただけでは動かない、というのは関数の基本ですが、非同期だとエラーも出ないので気づきにくいです。

エラー処理 —— ここが一番刺さる落とし穴

この節が、この記事で一番大事です。

まず、正しく書いてみる

async function main() {
  try {
    const res = await fetch("data.json");
    const json = await res.json();
    console.log(json.items.length);
  } catch (err) {
    console.error("失敗しました:", err);
  }
}

main();

.then() 版ならこうです。

fetch("data.json")
  .then((res) => res.json())
  .then((json) => console.log(json.items.length))
  .catch((err) => console.error("失敗しました:", err));

どちらも同じ意味です。 try / catch と .catch() は対応しています。

わざと404を踏む

さて、ここからが本題です。存在しないファイルを取りに行きます。

async function main() {
  try {
    const res = await fetch("nai.json");   // 存在しないファイル
    console.log("ここに来るはずがない、と思っていた");
    const json = await res.json();
    console.log(json);
  } catch (err) {
    console.error("失敗しました:", err);
  }
}

main();

nai.json は作っていません。当然404です。catch に飛ぶはずだと思いました。

実際の Console はこうなります。

ここに来るはずがない、と思っていた
失敗しました: SyntaxError: Unexpected token '<', "<!DOCTYPE "... is not valid JSON

2つ、おかしいことが起きています。

  1. fetch の次の行が実行されている。 404なのに例外が投げられていない
  2. エラーの内容がJSONの構文エラーになっている。404の話がどこにも出てこない

これが fetch の最大の落とし穴です。

fetch は、サーバーから返事が返ってきた時点で「成功」とみなします。 404 でも 500 でも、返事は返ってきています。だから成功です。 失敗(rejected)になるのは、そもそも返事が返ってこなかったときだけです。ネットワークが切れている、ホスト名が引けない、CORSで止められた——そういう場合です。

そして2つ目のエラーの理由も分かります。python3 -m http.server は404のとき、HTMLのエラーページを返します。 その <!DOCTYPE html>... を res.json() がJSONとして読もうとして、< の時点で「JSONじゃない」と怒っているわけです。

つまり、本当の原因(404)が、まったく別のエラー(JSON構文エラー)に化けています。 これがこのバグの一番たちの悪いところです。エラーメッセージを読んでも、原因にたどり着けません。

res.ok を自分で見る

対処は決まっています。fetch のあとに必ず1行入れます。

const res = await fetch(url);
if (!res.ok) throw new Error(`HTTP ${res.status}`);

さっき Response の中に status と ok があったのを見ました。あれを自分で確認します。

プロパティ中身
res.statusHTTPステータスコード(200、404、500 など)
res.okステータスが 200〜299 なら true、それ以外は false
res.statusText"OK" "Not Found" などの文字列

ステータスコードそのものは、DNS・HTTP・HTTPSの回でやった内容です。あのとき「404はサーバーが正常に応答した結果である」と書きましたが、それがそのままここに効いてきます。

書き直します。

async function main() {
  try {
    const res = await fetch("nai.json");
    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);
    const json = await res.json();
    console.log(json);
  } catch (err) {
    console.error("失敗しました:", err.message);
  }
}

main();
失敗しました: HTTP 404 File not found

今度は原因がそのまま出ました。

[スクリーンショット: 03_404.png] res.ok を見る前の「SyntaxError: Unexpected token ‘<‘」と、res.ok を入れた後の「HTTP 404 File not found」の両方が Console に並んでいる状態を撮ってください。同じ原因が違うエラーに化けていたことが伝わるようにします。

fetch を書いたら、必ず res.ok を見る。 例外にならないので、書き忘れても最初は動いてしまいます。壊れるのは、サーバー側が404や500を返し始めた本番です。

取ってきたデータを画面に出す

Console で確認できたので、画面に描きます。 前回の DOM 操作と繋がるところです。

HTML を用意する

~/web/index.html の <main> の中に、これを足します。

    <article id="async-demo">
      <h2>やることリスト</h2>
      <p id="status">読み込み中…</p>
      <ul id="task-list"></ul>
      <button id="reload">再読み込み</button>
    </article>

<ul> は空のままです。中身はJavaScriptが作ります。

script.js を書く

~/web/script.js を、これに置き換えます。

const statusEl = document.getElementById("status");
const listEl = document.getElementById("task-list");
const reloadBtn = document.getElementById("reload");

async function loadTasks() {
  statusEl.textContent = "読み込み中…";
  listEl.textContent = "";

  try {
    const res = await fetch("data.json");
    if (!res.ok) throw new Error(`HTTP ${res.status}`);

    const json = await res.json();

    for (const item of json.items) {
      const li = document.createElement("li");
      li.textContent = (item.done ? "[済] " : "[未] ") + item.title;
      listEl.appendChild(li);
    }

    statusEl.textContent = `${json.items.length}件(更新日 ${json.updated})`;
  } catch (err) {
    statusEl.textContent = "読み込みに失敗しました: " + err.message;
    console.error(err);
  }
}

reloadBtn.addEventListener("click", loadTasks);
loadTasks();

ブラウザを再読み込みすると、4件のリストが出ます。

[スクリーンショット: 04_リスト表示.png] data.json から読んだ4件が <ul> に並び、その上に「4件(更新日 2026-09-02)」と出ている画面を撮ってください。開発者ツールの Network タブで data.json が 200 で取れているところも一緒に写るとなお良いです。

前回と同じことをやっていますが、違いは「文字がコードの中に書かれていない」ことです。

data.json の中身を書き換えて、ブラウザの「再読み込み」ボタンを押すと、HTMLもJavaScriptも一切変えていないのに画面が変わります。 これが、データと表示を分けるということです。

なお、data.json を書き換えたのに変わらないときは、ブラウザがキャッシュしています。 Ctrl + Shift + R(スーパーリロード)で読み直してください。開発者ツールの Network タブにある「Disable cache」にチェックを入れておくのも有効です。これで無駄に悩む時間が確実に減ります。

「成功しか考えていないコード」を壊してみる

いま書いたコードには、try / catch と「読み込み中…」が入っています。なぜ要るのかを、壊して確かめます。

VMのターミナルで Ctrl + C を押してサーバーを止めてください。 その状態で、ブラウザの「再読み込み」ボタンを押します。

読み込みに失敗しました: Failed to fetch

画面にちゃんと出ます。Console にはこう出ます。

TypeError: Failed to fetch

これが、fetch が本当に rejected になるケースです。 404ではなく「返事が返ってこなかった」からです。

もし try / catch を書いていなかったら、どうなるか。画面は「読み込み中…」のまま止まります。 ユーザーから見れば、永遠に読み込み中です。何が起きたのか分かりません。

「成功しか考えていないコードは実戦で壊れる」 通信は必ず失敗します。電波が切れる、サーバーが落ちる、URLが変わる。 成功したときだけ正しい画面は、半分しかできていません。

表示すべき状態は、最低でも3つあります。

状態出すもの忘れるとどうなるか
読み込み中「読み込み中…」やスピナー画面が空白のまま。壊れたように見える
成功データ—
失敗理由と、やり直す手段永遠に読み込み中。ユーザーは何もできない

.then() で書く場合は .finally() が使えます。

fetch("data.json")
  .then((res) => { if (!res.ok) throw new Error(`HTTP ${res.status}`); return res.json(); })
  .then((json) => render(json))
  .catch((err) => { statusEl.textContent = "失敗: " + err.message; })
  .finally(() => { console.log("成功でも失敗でも、ここは通る"); });

finally は、成功でも失敗でも必ず通ります。 「読み込み中」の表示を消す処理は、ここに書くのが確実です。

サーバーを立て直しておいてください。

bash
$ cd ~/web
$ python3 -m http.server 8000 --bind 0.0.0.0

CORS —— ブラウザが止めている

次は、別のオリジンを叩いてみます。

2つ目のサーバーを立てる

VMの中で、もう1つターミナルを開いて(VS Code なら新しいターミナル、SSHならもう1本接続)、別のポートでサーバーを立てます。

bash
$ mkdir -p ~/other
$ cp ~/web/data.json ~/other/data.json
$ cd ~/other
$ python3 -m http.server 8001 --bind 0.0.0.0

これで、8000番と8001番の2つが動いている状態になります。

8001番を ufw で開ける —— ここを飛ばすと実験が成立しない

新しいポートを使うので、また開けます。 もう1本ターミナルを開いて(8001番のサーバーは動かしたままにします)、

bash
$ sudo ufw allow 8001/tcp
$ sudo ufw status
To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
8000/tcp                   ALLOW       Anywhere
8001/tcp                   ALLOW       Anywhere

開け忘れると、この節は「再現したように見えて、実は別の失敗」になります。

8001番が塞がっていると、ブラウザはそもそも繋がりません。 その場合 Console に出るのは

失敗: TypeError: Failed to fetch

だけで、blocked by CORS policy の行は出ません。 ところが最後の TypeError: Failed to fetch はCORSのときと同じ文言なので、「再現した」と勘違いしたまま先へ進めてしまいます。

さらに悪いことに、このあと VMの中で打つ curl はループバック(自分自身)宛なので ufw を通らず 200 を返します。 「curlは200、ブラウザは失敗」という結論まで一致してしまい、まったく別の原因の現象をCORSだと覚えてしまいます。

blocked by CORS policy: の行が出ているかどうかで見分けてください。 出ていなければ、原因はCORSではなくポートです。

別ポートを fetch する

ブラウザの Console で、8000番のページを開いたまま、こう打ちます。

fetch("http://192.168.226.50:8001/data.json")
  .then((r) => r.json())
  .then(console.log)
  .catch((e) => console.error("失敗:", e));
Access to fetch at 'http://192.168.226.50:8001/data.json' from origin
'http://192.168.226.50:8000' has been blocked by CORS policy:
No 'Access-Control-Allow-Origin' header is present on the requested resource.

失敗: TypeError: Failed to fetch

同じマシンの、同じファイルなのに、ポートが違うだけで止められます。

オリジンとは何か

オリジンは「プロトコル + ホスト + ポート」の3点セットです。1つでも違えば別のオリジンです。

URL8000番のページから見て
http://192.168.226.50:8000/other.json同一オリジン(OK)
http://192.168.226.50:8001/data.json別(ポートが違う)
https://192.168.226.50:8000/data.json別(プロトコルが違う)
http://localhost:8000/data.json別(ホスト名の文字列が違う。IPと同じ機械でも別扱い)

最後の行は特に厄介です。 localhost と 127.0.0.1 は同じ場所を指しますが、ブラウザは文字列で判断するので別オリジンです。

サーバーは応答している

ここが一番の誤解ポイントでした。私は「CORSエラー=サーバーが拒否した」と思っていました。違います。

VMの中で curl を打ってみます。

bash
$ curl -i http://192.168.226.50:8001/data.json
HTTP/1.0 200 OK
Content-type: application/json
...
{ "updated": "2026-09-02", ... }

200 で、中身も返っています。

ブラウザの Network タブを見ると、そのリクエストは Status が CORS error と表示されます(Chrome / Edge)。ここで注意したいのは、これは「サーバーが CORS error を返した」という意味ではないことです。サーバーは 200 を返していて、ブラウザがそれを握り潰した、という表示です。上の curl が 200 なのがその証拠です。

Firefox では Status に 200 がそのまま出ます。 ブラウザによって表示が違うのも、この現象が「サーバーの応答」ではなく「ブラウザの判断」だからです。

CORSエラーは、ブラウザが止めています。サーバーは正常に応答しています。 「サーバーの応答を、JavaScript に渡してよいか」をブラウザが判断していて、 サーバーが Access-Control-Allow-Origin ヘッダで「渡していいよ」と言っていないから渡さない、という動きです。

だから、この問題はフロントエンド側では直せません。 直すのはサーバー側です(Access-Control-Allow-Origin ヘッダを返すようにする)。ここは第5段階でバックエンドを書くときにやります。

Console に「CORS」と出たら、まずサーバー側の設定を疑ってください。 JavaScript を何度書き直しても直りません。私はここで2時間溶かしました。

[スクリーンショット: 05_cors.png] Console の赤いCORSエラーと、VMのターミナルで打った curl が 200 を返しているところを、並べて撮ってください。「サーバーは応答しているのにブラウザが渡さない」が一目で分かるようにします。

file:// で開くと fetch が失敗する理由

もうひとつ、初心者が100%踏む罠です。

VMの中のファイルを、仮にホスト側にコピーしてダブルクリックで開いたとします。アドレスバーはこうなります。

file:///C:/Users/user/Desktop/index.html

この状態で fetch("data.json") を実行すると、同じフォルダにあるのに失敗します。

Access to fetch at 'file:///C:/Users/user/Desktop/data.json' from origin 'null'
has been blocked by CORS policy: Cross origin requests are only supported for
protocol schemes: http, https, ...

from origin 'null' に注目してください。

file:// にはホストもポートもありません。オリジンを作れないので、ブラウザは null を割り当てます。 そして null は何とも一致しないので、自分自身のフォルダですら「別のオリジン」扱いになります。

file:// で開くと fetch は使えません。 これは不具合ではなく、そういう仕様です。 だからこの記事は最初から python3 -m http.server を立てさせています。 HTMLとCSSだけならダブルクリックで足りましたが、fetch を使い始めた瞬間からサーバーが必須になります。

「サーバーを立てる」の意味が、ここで一段深くなります。 ただ表示するためではなく、オリジンを持つためです。

並行して待つ —— Promise.all

最後に、速さの話です。

直列に await すると遅い

3つのデータを取る例を考えます。まず、時間がかかる処理を再現する道具を用意します。

const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function load(name) {
  await wait(1000);                 // 1秒かかる通信のつもり
  const res = await fetch("data.json");
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const json = await res.json();
  return { name, count: json.items.length };
}

素直に書くと、こうなります。Console に貼ってください。

async function serial() {
  console.time("直列");
  const a = await load("A");
  const b = await load("B");
  const c = await load("C");
  console.timeEnd("直列");
  console.log(a, b, c);
}
serial();
直列: 3012.4 ms

約3秒かかります。

理由は単純で、await は「そこで止まって待つ」からです。 Aが終わるまでBを始めません。

[A 1秒] → [B 1秒] → [C 1秒]   合計3秒

しかし、AとBとCは互いに関係ありません。同時に始められるはずです。

Promise.all で同時に始める

async function parallel() {
  console.time("並行");
  const [a, b, c] = await Promise.all([load("A"), load("B"), load("C")]);
  console.timeEnd("並行");
  console.log(a, b, c);
}
parallel();
並行: 1008.7 ms

約1秒。3分の1になりました。

[A 1秒]
[B 1秒]   同時に走る   合計1秒
[C 1秒]

違いは1箇所だけです。

書き方動き
await load("A"); await load("B");Aが終わってからBを始める(直列)
Promise.all([load("A"), load("B")])AとBを同時に始めて、両方揃うまで待つ(並行)

Promise.all は配列を受け取って、配列を返します。 順番は書いた通りに保たれるので、[a, b, c] で受け取れます。

Promise.all は、1つでも失敗すると全体が失敗します。 「3つのうち2つ取れれば表示したい」場合は Promise.all ではなく Promise.allSettled を使います。こちらは全部の結果(成功も失敗も)を配列で返します。

使い分け

なんでも Promise.all にすればいいわけではありません。

前の結果が次に必要なら、直列にするしかありません。

// これは Promise.all にできない(idが取れないとdetailを呼べない)
const user = await getUser();
const detail = await getDetail(user.id);

判断基準はひとつです。

「この2つは、お互いの結果を必要とするか?」 必要としないなら Promise.all。必要とするなら直列。

関係ないものを直列に並べているコードは、ただ遅いだけです。 これは実際のアプリで、体感速度に直結します。

よくあるエラーと、その読み方

つまずいた分をまとめておきます。

Console の表示本当の原因やること
値が undefined結果が来る前に読んでいるawait するか .then() の中に処理を移す
Cannot read properties of undefinedPromise のまま .items を読んだawait を付け忘れていないか確認
await is only valid in async functions...関数に async が無いasync function にする
Unexpected token '<' ... is not valid JSONたいてい404。 HTMLのエラーページをJSONとして読んでいるif (!res.ok) throw ... を入れる
Failed to fetch返事が返ってきていない。 サーバーが落ちている / URLが違う / CORSで止まったサーバーが動いているか、Network タブを見る
blocked by CORS policyブラウザが止めている。サーバー側の設定の問題JavaScript を直しても無駄。サーバー側で許可する
from origin 'null'file:// で開いているpython3 -m http.server を立ててHTTPで開く
データが古いまま変わらないブラウザのキャッシュCtrl + Shift + R / Disable cache

エラーメッセージが原因を直接指していないケースがある、というのがこの回の学びでした。特に4行目の Unexpected token '<' は、JSONの話に見えて実はHTTPの話です。

片付け

試した2つ目のサーバーを止めておきます。VMの中のそれぞれのターミナルで Ctrl + C です。

bash
$ rm -rf ~/other

CORSの実験のために開けた 8001番を閉じます。

bash
$ sudo ufw delete allow 8001/tcp
$ sudo ufw status

8001/tcp の行が消えていれば片付け完了です。8000番は次回以降も使うので、開けたままにしておきます。

script.js を元に戻したいときは、最初に取ったバックアップを使います。

bash
$ cp ~/web/script.js.bak ~/web/script.js

data.json と、リスト表示のコードは残しておいてください。 データを外から読んで表示する形は、この先ずっと使います。

まとめ

  • undefined になるのは書き方の間違いではない。 結果が来る前に次の行が実行されているだけ
  • JavaScript は1本の線でしか動かない。 だから待たずに「終わったら呼んでね」と予約して先に進む
  • 時間のかかる処理は、結果が後から来る。 console.log の順番が書いた順にならないのはそのため
  • Promise はまだ無い結果の引換券。 pending / fulfilled / rejected の3状態で、一度決まったら変わらない
  • .then() の中で Promise を return すると、次の .then() が待ってくれる。 書き忘れると全部いっぺんに走る
  • await は .then() の書き換えであって別物ではない。 try / catch は .catch() に対応する
  • await は async の中でしか使えない。 関数の外で使えるのは type="module" のときだけ
  • async を付けた関数の戻り値は必ず Promise。 呼ぶ側も await しないと値は取れない
  • fetch は404や500では例外にならない。 if (!res.ok) throw new Error(...) を自分で書く
  • CORSエラーはブラウザが止めている。サーバーは応答している。 フロント側では直せない
  • file:// で開くと fetch は失敗する。 オリジンが null になるため。サーバーが必須
  • 関係のない通信を直列に await すると、待ち時間が足し算になる。 Promise.all で並行にする
  • 成功しか考えていないコードは実戦で壊れる。 読み込み中・成功・失敗の3つの表示を必ず用意する

参考リンク


次に読む

この記事は 【第3段階】プログラミング の 6 / 7 本目です。

記事
← 前の記事node_modulesは消してよい — npmとパッケージ管理
→ 次の記事dist/ の中身は何なのか — ビルドツールとVite

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次