useEffect — その多くは要らない

useEffectを見直す。ブラウザと外部機器、同期マークと確認用チェックリスト。

useEffectで書いた処理の多くは、そもそも要りません。依存配列と副作用の考え方を整理して、書かない判断ができるようにします。

前回: useStateとuseReducer — 読み込み中なのにエラーもある

これは深掘りです。本線の順路ではありません。 本線のコンポーネントとpropsの回で state の持ち方まで進んだ人が、「画面が出たあとに何かしたい」と思って useEffect を書き始めたところで、原因の分からない挙動に当たったときに読む記事です。飛ばしても本線は進みます。

この記事のコマンドは、すべて VM(Ubuntu Server)の中で打ちます。 Windows の PowerShell ではありません。 画面の確認は、ホストの Windows のブラウザで行います。 本線で作った ~/react-demo/ には触りません。 この記事では、まっさらな ~/reactlab/ を新しく作り、ポート 5175番で動かします。

useEffect を覚えた直後、私のコンポーネントはこうなりました。

useEffect(() => {
  setFullName(firstName + ' ' + lastName)
}, [firstName, lastName])

動きます。 名前を打つと、フルネームが下に出ます。それで満足して、次に進みました。

そのあと起きたことを、順番に書きます。

  1. 1文字ごとに描画が1回多く走るようになった(環境によっては古いフルネームが一瞬見えることもある)
  2. useEffect の中で setState して、その state をまた別の useEffect が見て、無限ループで画面が固まった
  3. 検索ボックスを作ったら、打った文字と違う検索結果が表示されるようになった
  4. 開発中だけ、API が2回叩かれるようになった

この4つは、全部ばらばらの問題に見えました。 実際には、根っこは1つでした。

useEffect は「画面が出たあとに何かする道具」ではありません。 React の外にあるものと、無理やり同期を取るための、最後の手段です。 だから、書いた瞬間に「同期を取る」という難しい仕事が1つ増えます。 バグはそこから生えます。

React の公式ドキュメントにも、You Might Not Need an Effect(Effect は要らないかもしれない) という、書き方ではなく「消し方」を教えるページがあります。公式が最初に言うのが「まず消せ」なのです。

この記事は、その立場で書きます。使い方より先に、要らない useEffect を4つ消します。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • useEffect の大半は要らないこと。「レンダー後に何かしたい」は、たいてい useEffect の仕事ではない
  • 他の state や props から計算できる値を useEffect + setState で作ってはいけないこと。描画のたびに計算すればよく、そのほうが速くて、ズレようがない
  • 「ボタンを押したときに何かする」を useEffect で書くと壊れること。それはイベントハンドラの仕事で、effect は「押したこと」ではなく「表示されていること」に反応する
  • 本当に要るのは「React の外」と繋ぐときだけであること。ブラウザAPI・購読・タイマー・ネットワークの4つ
  • 後片づけ(cleanup)を書かないと、同じ処理が多重に動くこと。「たまに2倍速くなる」の正体
  • 開発中に effect が2回動くのは StrictMode で、バグではなく「後片づけを書き忘れていないか」の検査であること
  • 依存配列は「書かない / [] / [a, b]」で意味がまるで違うこと。そして、警告を消すために依存を削ると、古い値を掴んだまま動き続ける
  • 同じ検索ボックスに速く打つと、古い結果が新しい結果を上書きする(競合状態)こと。これは useEffect でデータ取得する限り自分で防ぐしかない
  • 結論として、データ取得に useEffect を使わないという選択肢があること

この記事でやること

  1. ~/reactlab/ を新しく作り、ポート 5175番で起動する
  2. 要らない useEffect を4種類、実際に書いてから消す(派生値 / props→state / イベント / 親への通知)
  3. 本当に要る例を1つ実装する(ウィンドウの幅を表示する。addEventListener と後片づけ)
  4. 後片づけを書かないタイマーを作って、多重に動くところを見る
  5. 依存配列を [] にして、古い値を掴んだまま動き続けるところを確かめる
  6. 検索ボックスで競合状態を再現し、ignore フラグと AbortController で直す

先に知る言葉

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

言葉意味
effect(エフェクト)描画そのものではなく、描画の結果として外に起こす作用。React では useEffect に渡す関数のこと
副作用(side effect)返り値以外に、外の世界を変えてしまう処理。DOMを直接いじる、通信する、タイマーを張る、など
購読(subscribe)「何かが起きたら教えて」と外の仕組みに登録すること。addEventListener がその代表
後片づけ(cleanup)登録したものを、要らなくなったときに解除する処理。useEffect の中で関数を return すると、それが後片づけになる
依存配列(dependency array)useEffect(fn, [a, b]) の [a, b] の部分。この中の値が前回と変わったときだけ、effect をやり直す
マウント / アンマウントコンポーネントが画面に出ること / 画面から消えること
競合状態(race condition)複数の処理が競争していて、どちらが先に終わるかで結果が変わってしまう状態
AbortController進行中の通信を、途中で打ち切るためのブラウザ標準の道具
keyリストの key と同じもの。React が「これは同じ部品か、別の部品か」を判断する目印

1つだけ、先に頭に入れてください。 useEffect は「〜したとき」に動くものではありません。 「〜という状態で表示されている間、外の世界をこう保て」という指示です。 「したとき」と読むか「保て」と読むかで、この記事の後半の全部が変わります。


① 準備 — reactlab を作る

本線で作った ~/react-demo/ は、そのまま残します。 この記事はわざと壊す手順を含むので、別のプロジェクトでやります。

VM の中で打ちます。

bash
$ cd ~
$ npm create vite@latest reactlab -- --template react

「このまま依存を入れて起動しますか」と聞かれたら No(n)を選んでください。ポートを自分で決めたいからです。

bash
$ cd ~/reactlab
$ npm install
$ ls
eslint.config.js  index.html  package.json  public  README.md  src  vite.config.js

この一覧が出れば成功です。 npm install は初回だけ数分かかります(npmの回)。

ポートを開ける

本線で 5173番、別の深掘りで 5174番を使っています。 ぶつからないように、この記事は 5175番でやります。

bash
$ sudo ufw allow 5175/tcp
$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
5173/tcp                   ALLOW       Anywhere
5175/tcp                   ALLOW       Anywhere

5175/tcp の行が出れば準備完了です。開けずに起動すると、ターミナルには「起動しました」と出るのに、ブラウザは読み込み中のままになります(ネットワークの回)。

起動する

bash
$ npm run dev -- --host 0.0.0.0 --port 5175

ホストの Windows のブラウザで http://192.168.226.50:5175/ を開きます(IPは自分の値に。分からなければ VM の中で ip a)。Vite のロゴとカウンターが出れば成功です。

[スクリーンショット: 01_reactlab起動5175.png] ホストのブラウザで :5175 を開き、Vite + React の初期画面が出ているところを撮ってください。アドレスバーのポート番号が 5175 になっているのが見える形で。

止め方: ターミナルで Ctrl+C。この記事の間は起動したままで構いません。 保存するたびにブラウザが自動で更新されます。

編集は VS Code から VM を開いて行います(VS Code Remote の回)。

コンソールを開けたままにする

この記事は、画面よりコンソールを見る時間のほうが長くなります。 ホストのブラウザで F12 を押して、Console タブを出したままにしてください(開発者ツールの回)。

通信を見る場面もあるので、Network タブがあることも確認しておいてください。


② 要らない useEffect を、4つ並べて消す

ここがこの記事の芯です。

これから4つ書きます。4つとも、動きます。 動くのに、全部間違いです。 1つずつ、書いて → 壊れ方を見て → 消します。

①要らない — 他の値から計算できるものを、effect で作る

src/components/NameForm.jsx を新規作成します。わざと間違った版です。

import { useState, useEffect } from "react";

export default function NameForm() {
  const [firstName, setFirstName] = useState("太郎");
  const [lastName, setLastName] = useState("山田");
  const [fullName, setFullName] = useState("");

  useEffect(() => {
    console.log("effect が動いた");
    setFullName(lastName + " " + firstName);
  }, [firstName, lastName]);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <input value={lastName} onChange={(e) => setLastName(e.target.value)} />
      <input value={firstName} onChange={(e) => setFirstName(e.target.value)} />
      <p>フルネーム: {fullName}</p>
    </div>
  );
}

src/App.jsx を、中身を全部消してこう書き換えます。

import NameForm from "./components/NameForm";

export default function App() {
  return (
    <div style={{ padding: "24px", fontFamily: "sans-serif" }}>
      <h1>reactlab</h1>
      <NameForm />
    </div>
  );
}

保存して、名字の欄に1文字足してください。 表示は正しく更新されます。「動いた」で終われます。

ですが、Console を見てください。 1文字打つたびに effect が動いた が出て、その後にもう一度コンポーネントが呼ばれています。

何が起きているか、順番に書きます。

順起きること
1文字を打つ → setLastName → 1回目の描画。このとき fullName はまだ古い
2古いフルネームのまま描画が1回終わる(画面に出るかはタイミング次第)
3描画が終わってから effect が動き、setFullName
42回目の描画。ようやく正しくなる

1文字打つたびに、画面を2回描いています。 しかも、1回目は間違った内容で描画しています。 入力やクリックが原因の effect は、ブラウザが画面を塗る前に動くことがあるので、古い値が目に見えるとは限りません。 問題は「無駄な描画が1回ぶん増える」ことで、遅い環境やリストが大きい画面ほど効いてきます。

直します。 fullName は state ではありません。 firstName と lastName が決まれば、必ず決まる値です。

import { useState } from "react";

export default function NameForm() {
  const [firstName, setFirstName] = useState("太郎");
  const [lastName, setLastName] = useState("山田");

  const fullName = lastName + " " + firstName;

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <input value={lastName} onChange={(e) => setLastName(e.target.value)} />
      <input value={firstName} onChange={(e) => setFirstName(e.target.value)} />
      <p>フルネーム: {fullName}</p>
    </div>
  );
}

消えたものを数えてください。

前後
useState3個2個
useEffect1個0個
1文字打つときの描画2回1回
古い値で描画される回ある(見えるかはタイミング次第)ない
importuseState, useEffectuseState

行数も減りました。 useEffect を消したのに、機能は1つも減っていません。

これは、propsの深掘り回で「合計を state に持つとズレる」とやった話の、まったく同じ形です。 あちらは「持たない」で終わりましたが、useEffect を覚えると「持ったうえで同期する」という第3の道が見えてしまいます。 その道は、遅くて、ちらついて、ズレます。 道が3本あるように見えるだけで、正解は「持たない」1本のままです。

[スクリーンショット: 02_effectで2回描画.png] 壊れている版で1文字打ったあとの Console を撮ってください。effect が動いた が出ているのが読みどころです。

②要らない — props が変わったら state を更新する

次はこれです。 「一覧から人を選ぶと、その人の情報が右に出る。選び直したら、右の入力欄を空に戻したい」。

src/components/Profile.jsx を作ります。わざと間違った版です。

import { useState, useEffect } from "react";

export default function Profile({ userId }) {
  const [memo, setMemo] = useState("");

  useEffect(() => {
    setMemo("");
  }, [userId]);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>ユーザー: {userId}</p>
      <input
        value={memo}
        onChange={(e) => setMemo(e.target.value)}
        placeholder="この人へのメモ"
      />
      <p>いまのメモ: {memo}</p>
    </div>
  );
}

src/App.jsx から使います。

import { useState } from "react";
import Profile from "./components/Profile";

export default function App() {
  const [userId, setUserId] = useState("taro");

  return (
    <div style={{ padding: "24px", fontFamily: "sans-serif" }}>
      <h1>reactlab</h1>
      <button onClick={() => setUserId("taro")}>taro</button>
      <button onClick={() => setUserId("jiro")}>jiro</button>
      <Profile userId={userId} />
    </div>
  );
}

メモを打ってから、jiro を押してください。 メモは消えます。動いています。

ですが、①とまったく同じ問題があります。 jiro を押した瞬間、1回目の描画では memo が taro のときのまま残っています。 そのあと effect が動いて空になり、2回目の描画で消えます。

押した瞬間に、他人のメモのまま1回描画しているということです(クリックが原因なので画面に見えないことも多いですが、無駄な描画であることは変わりません)。

直し方が2つあります。 どちらを選ぶかは、「その state を丸ごと捨てたいか、一部だけ直したいか」で決まります。

直し方A — key で作り直す(丸ごと捨てるとき)

Profile から useEffect を消します。

import { useState } from "react";

export default function Profile({ userId }) {
  const [memo, setMemo] = useState("");

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>ユーザー: {userId}</p>
      <input
        value={memo}
        onChange={(e) => setMemo(e.target.value)}
        placeholder="この人へのメモ"
      />
      <p>いまのメモ: {memo}</p>
    </div>
  );
}

代わりに、呼び出す側で key を渡します。

      <Profile key={userId} userId={userId} />

押してください。 メモは消えます。しかも、古い値で描画する回がありません。

key が変わると、React はそれを「別の部品」だと判断します。 前のものを捨てて、新しいものを作り直します。 useState("") から始まるので、空になるのは当たり前です。 「消す処理」を書いていません。 消す必要がなくなったのです。

リストの key と、まったく同じ仕組みです。 リストで key を付けるのは「並べ替えたときに中身が入れ替わらないように」でしたが、その逆向きの使い方がこれです。

直し方B — 描画中に更新する(一部だけ直したいとき)

丸ごと捨てられない場合もあります。 たとえば「メモは消したいが、開いている・閉じているの状態は保ちたい」ようなときです。

この場合は、useEffect ではなく、描画中に直接直します。

import { useState } from "react";

export default function Profile({ userId }) {
  const [memo, setMemo] = useState("");
  const [prevUserId, setPrevUserId] = useState(userId);

  if (userId !== prevUserId) {
    setPrevUserId(userId);
    setMemo("");
  }

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>ユーザー: {userId}</p>
      <input
        value={memo}
        onChange={(e) => setMemo(e.target.value)}
        placeholder="この人へのメモ"
      />
      <p>いまのメモ: {memo}</p>
    </div>
  );
}

「描画中に setState を呼んでいる。無限ループでは?」と思うはずです。 私も思いました。

ループしません。 if の中で setPrevUserId(userId) を呼んでいるので、次にこの関数が呼ばれたときには userId === prevUserId になり、if に入りません。

そして、これは effect より速いです。

useEffect 版描画中に更新する版
描画される回数古い値で1回描画してから、正しい値正しい値だけ
React の動き描画 → DOMに反映 → effect → 描画 → DOMに反映描画 → 中断 → 描画 → DOMに反映

React は、描画の途中で setState されたら、その回の結果を捨ててやり直します。 まだ DOM に何も書いていないので、画面はちらつきません。 useEffect は「DOMに書き終わったあと」に動くので、古い値が一度 DOM に書かれます(クリックや入力が原因なら画面を塗る前に effect が動くことがあり、目に見えるとは限りません)。 この差です。

ただし、これは見た目より繊細な書き方です。 迷ったら A(key)を選んでください。 A で足りる場面のほうが、圧倒的に多いです。

[スクリーンショット: 03_keyで作り直す.png] key={userId} を付けた状態で、taro にメモを打ってから jiro を押し、メモが空になっているところを撮ってください。

③要らない — イベントに反応する処理を effect に書く

ここが、この記事で一番多い間違いです。

「送信したら、通知を出す」を、effect で書いてみます。src/components/Notify.jsx を作ります。

import { useState, useEffect } from "react";

export default function Notify() {
  const [submitted, setSubmitted] = useState(false);
  const [dark, setDark] = useState(false);

  useEffect(() => {
    if (submitted) {
      console.log("送信しました!(通知)");
    }
  }, [submitted, dark]);

  return (
    <div
      style={{
        border: "1px solid #ccc",
        padding: "12px",
        margin: "8px 0",
        background: dark ? "#333" : "#fff",
        color: dark ? "#fff" : "#000",
      }}
    >
      <button onClick={() => setSubmitted(true)}>送信する</button>
      <button onClick={() => setDark(!dark)}>配色を変える</button>
      <p>submitted: {String(submitted)}</p>
    </div>
  );
}

App.jsx に import Notify from "./components/Notify"; を足し、<Notify /> を並べます。

「送信する」を押してください。 Console に 送信しました!(通知) が出ます。正しく動いています。

次に、「配色を変える」を押してください。

送信しました!(通知)

もう一度、通知が出ました。 送信していないのに、です。

もう一度押してください。また出ます。 配色を切り替えるたびに、「送信しました」と言い続けます。

なぜか。 effect は「押されたこと」を知りません。 effect が知っているのは、「いま、依存配列の中身がこうなっている」という事実だけです。

何を書いたかReact が読んだ意味
私が書きたかったこと「送信ボタンが押されたら、通知を出す」
実際に書いたこと「submitted か dark が変わって再描画されるたび、submitted が true なら通知を出す」

「dark を依存配列から外せばいい」と思うかもしれません。 それは⑤でやる「依存を嘘つきにする」という、もっと悪い手です。 そもそも解き方が違います。

直します。 useEffect も、submitted という state も、丸ごと消えます。

import { useState } from "react";

export default function Notify() {
  const [dark, setDark] = useState(false);

  const handleSubmit = () => {
    console.log("送信しました!(通知)");
  };

  return (
    <div
      style={{
        border: "1px solid #ccc",
        padding: "12px",
        margin: "8px 0",
        background: dark ? "#333" : "#fff",
        color: dark ? "#fff" : "#000",
      }}
    >
      <button onClick={handleSubmit}>送信する</button>
      <button onClick={() => setDark(!dark)}>配色を変える</button>
    </div>
  );
}

押してください。 送信のときだけ通知が出て、配色を変えても何も出ません。

判断の基準は、たった1つです。 「これは、ユーザーが特定の操作をしたから起きることか?」 → はい なら、イベントハンドラに書く 「これは、この画面が表示されている限り、外の世界とこうなっていてほしいという話か?」 → はい なら、effect

表にします。

やりたいことどちらか理由
ボタンを押したら送信するイベントハンドラ押したから起きる
送信が終わったら通知を出すイベントハンドラ(送信処理の続きに書く)押したから起きる
買い物かごに入れたら記録を送るイベントハンドラ押したから起きる
この画面を開いている間、チャットサーバーに繋いでおくeffect表示されているから、そうであってほしい
この画面を開いている間、ウィンドウ幅を追いかけるeffect同上

「終わったあとに」という言葉に引っ張られないでください。 「送信のあとに通知」は、時間の前後の話であって、useEffect の話ではありません。 同じ関数の中で、下の行に書けば済みます。

[スクリーンショット: 04_押していないのに通知.png] 壊れている版で「配色を変える」だけを押し、Console に「送信しました!(通知)」が並んでいるところを撮ってください。

④要らない — 親に伝えるために effect を使う

最後の1つです。 「子の値が変わったら、親に知らせたい」。

よく書かれるのがこれです。

function Toggle({ onChange }) {
  const [on, setOn] = useState(false);

  useEffect(() => {
    onChange(on);
  }, [on, onChange]);

  return <button onClick={() => setOn(!on)}>{on ? "ON" : "OFF"}</button>;
}

これも、③と同じ問題を持っています。

  • 最初に表示されただけで、1回 onChange(false) が呼ばれます。 何も操作していないのに、です
  • 押したときの流れが遠回りです。 押す → state を更新 → 描画 → DOMに反映 → やっと親に伝わる
  • 親がそれを受けて自分の state を更新すると、もう1回描画が走ります

直します。

function Toggle({ onChange }) {
  const [on, setOn] = useState(false);

  const handleClick = () => {
    const next = !on;
    setOn(next);
    onChange(next);
  };

  return <button onClick={handleClick}>{on ? "ON" : "OFF"}</button>;
}

押したときに、そのまま呼べばいいだけです。 「state が変わったのを検知して伝える」のではなく、「変えると決めた瞬間に、両方やる」。 setOn(next) と onChange(next) が並んでいるので、読む人にも「この2つは同じ操作の一部だ」と分かります。

なお、on を親が使うのなら、そもそも Toggle に state を持たせないという選択もあります。それがpropsの深掘り回でやったリフトアップです。 「同じ値を2箇所に持って同期する」より、「1箇所に持つ」ほうが常に強い手です。

4つを並べる

消したもの元の書き方直し方
① 派生値useEffect(() => setB(f(a)), [a])描画中に const b = f(a)
② props→stateuseEffect(() => setX(""), [id])key={id} で作り直す/描画中に if で更新
③ イベントuseEffect(() => { if (done) ... }, [done])イベントハンドラに書く
④ 親への通知useEffect(() => onChange(v), [v])変えた場所で、そのまま呼ぶ

4つに共通しているのは、これです。

どれも、React の中だけで完結する話でした。 外の世界は1つも出てきません。 通信もしていない、タイマーも張っていない、ブラウザのAPIも触っていない。 useEffect は「Reactの外と繋ぐ」道具なので、外が出てこない時点で、出番ではありません。


③ 本当に要るのは「外の世界と同期するとき」

消してばかりでは、いつ使うのか分かりません。 ここで、useEffect の正しい定義を1つだけ置きます。

useEffect は、「React が管理していないもの」と、「React の state」を、同期させ続けるためのものです。

「React が管理していないもの」とは、具体的にこの4つです。

外の世界例
ブラウザのAPIwindow のサイズ、スクロール位置、document.title、localStorage
購読addEventListener、外部ストアの変更通知
タイマーsetInterval、setTimeout
ネットワーク通信全般(ただし⑦で「使わない」という結論になります)

この4つ以外が出てきたら、まず②に戻ってください。

実際に作る — ウィンドウの幅を表示する

window の幅は、React の外にあります。 ユーザーがウィンドウをドラッグして変えても、React には何も伝わりません。 だから、こちらから「変わったら教えて」と登録しに行く必要があります。

src/components/WindowSize.jsx を作ります。

import { useState, useEffect } from "react";

export default function WindowSize() {
  const [width, setWidth] = useState(window.innerWidth);

  useEffect(() => {
    console.log("購読を開始した");

    const handleResize = () => {
      setWidth(window.innerWidth);
    };

    window.addEventListener("resize", handleResize);

    return () => {
      console.log("購読を解除した");
      window.removeEventListener("resize", handleResize);
    };
  }, []);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>ウィンドウの幅: {width}px</p>
    </div>
  );
}

App.jsx に import WindowSize from "./components/WindowSize"; を足し、<WindowSize /> を並べます。

ブラウザのウィンドウを、マウスで横に伸縮させてください。 数字が追いかけてきます。

この effect を、行ごとに読みます。

行意味
useState(window.innerWidth)初期値は、その場で読む。 ここは effect ではない
window.addEventListener(...)外の世界への登録。これが「同期の開始」
return () => { ... }後片づけ。「同期の終了」
[]依存が何も無い=一度繋いだら、繋ぎ直す理由が無い

return で関数を返すのが、useEffect の本体です。 「開始」と「終了」が対になっていない effect は、たいてい間違っています。 addEventListener を書いたら removeEventListener、setInterval を書いたら clearInterval。 セットで書けないなら、そもそも effect の使い方を間違えています。

後片づけが動くところを、目で見る

「後片づけなんて、ページを閉じるときにしか動かないのでは」と思うかもしれません。 違います。 コンポーネントが画面から消えるたびに動きます。

App.jsx で、WindowSize を出したり消したりできるようにします。

import { useState } from "react";
import WindowSize from "./components/WindowSize";

export default function App() {
  const [show, setShow] = useState(true);

  return (
    <div style={{ padding: "24px", fontFamily: "sans-serif" }}>
      <h1>reactlab</h1>
      <button onClick={() => setShow(!show)}>表示を切り替える</button>
      {show && <WindowSize />}
    </div>
  );
}

Console を開いたまま、切り替えボタンを何回か押してください。

購読を解除した
購読を開始した
購読を解除した
購読を開始した

消すたびに解除され、出すたびに開始されています。

これが、useEffect が「〜したとき」ではなく「〜である間」だと言った意味です。

WindowSize が表示されている間だけ、resize を購読している。 表示が終われば、購読も終わる。 「開始」と「終了」の両方をこちらが書くから、React はそれを守れます。

[スクリーンショット: 05_購読の開始と解除.png] 切り替えボタンを数回押したあとの Console を撮ってください。「購読を開始した」と「購読を解除した」が交互に並んでいるのが読みどころです。


④ 後片づけを書かないと、多重に動く

後片づけを書かないと何が起きるか。 「動かなくなる」のではありません。 「動きすぎる」のです。これが厄介です。

わざと壊す

src/components/BadTimer.jsx を作ります。後片づけを、わざと書きません。

import { useState, useEffect } from "react";

export default function BadTimer() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log("タイマーを張った");
    setInterval(() => {
      setCount((c) => c + 1);
    }, 1000);
  });

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>カウント: {count}</p>
    </div>
  );
}

依存配列を書いていないことに注目してください。 これは⑤で扱いますが、「毎回の描画のあとに動く」という意味です。

App.jsx に <BadTimer /> を足して、画面を見てください。

最初の数秒は 1, 2, 3 と普通に進みます。 そのあと、加速します。

0 → 1 → 2 → 4 → 8 → 16 → 32 → 64 ...

Console を見ると、タイマーを張った が、止まらずに増え続けています。

何が起きているか。

順起きること
1描画 → タイマーを1本張る
21秒後、setCount → 再描画
3依存配列が無いので、再描画のたびに effect がまた動く → タイマーが2本目
41秒後、2本が同時に setCount → 2回描画 → タイマーが4本目、8本目
5タイマーが倍々に増えて、ブラウザが固まる

ここでブラウザが重くなったら、そのタブを再読み込みしてください。 タイマーはページを再読み込みすれば全部消えます。

これが「後片づけを書かない」ということの意味です。 effect は、条件が変わればもう一度動きます。 前回の分を止めていないので、積み重なります。 「たまに処理が2倍速く動く」「通信が何十回も飛ぶ」「画面を行き来していたら重くなった」の正体は、ほぼこれです。

[スクリーンショット: 06_タイマー多重.png] カウントが異常な速さで増えている画面と、Console に「タイマーを張った」が大量に並んでいるところを撮ってください。

直す

2箇所直します。 後片づけを書くのと、依存配列を付けるのと、両方です。

src/components/GoodTimer.jsx として作り直します。

import { useState, useEffect } from "react";

export default function GoodTimer() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log("タイマーを張った");
    const id = setInterval(() => {
      setCount((c) => c + 1);
    }, 1000);

    return () => {
      console.log("タイマーを止めた");
      clearInterval(id);
    };
  }, []);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>カウント: {count}</p>
    </div>
  );
}

App.jsx の <BadTimer /> を <GoodTimer /> に差し替えて、BadTimer.jsx は消してください。

bash
$ rm ~/reactlab/src/components/BadTimer.jsx

画面を見てください。 1秒に1ずつ、一定の速さで増えます。

後片づけの型は、いつもこれです。

useEffect(() => {
  // ① 外の世界に、何かを始める
  return () => {
    // ② ①で始めたものを、必ず止める
  };
}, [依存]);
始めたもの止めるもの
addEventListenerremoveEventListener
setIntervalclearInterval
setTimeoutclearTimeout
接続する(WebSocketなど)切断する
通信を始める結果を無視するか、中断する(⑥でやります)

StrictMode で2回動くのは、これを見つけるため

ここまでやると、StrictMode の意味が分かります。

GoodTimer を表示した直後の Console を、もう一度見てください。

タイマーを張った
タイマーを止めた
タイマーを張った

1回しか表示していないのに、「張った → 止めた → 張った」と3行出ています。

これはバグではありません。 開発中だけ、React が effect をわざと1回動かして、すぐ後片づけして、もう一度動かしています。

理由は、たった1つです。 「後片づけを書き忘れていないか」を、その場で暴くため。 後片づけが正しければ、2回目は1回目と同じ状態から始まるので、何も変わりません。 後片づけが無ければ、BadTimer のように、2本目が積み重なって、すぐに見た目がおかしくなります。

再描画の深掘り回で、StrictMode がコンポーネントを2回呼ぶ話をしました。 同じ仕組みが、effect にも効いています。

開発中(npm run dev)本番(npm run build 後)
コンポーネントの関数2回呼ばれる1回
effect動く → 後片づけ → もう一度動く1回だけ動く

「開発中に API が2回叩かれる」の正体も、これです。 StrictMode を外して解決してはいけません。 外すと、見えなくなるだけで、直っていません。

確認の型を1つ。

  • 「張った → 止めた → 張った」の3行なら → 正常。後片づけが効いている
  • 「張った → 張った」の2行なら → 後片づけが無い。 直す

⑤ 依存配列 — 3つの意味と、絶対にやってはいけないこと

useEffect の第2引数は、3通りの書き方があります。 意味がまるで違います。

書き方いつ動くか使う場面
useEffect(fn)(書かない)毎回の描画のあと、必ずほぼ無い。 ④で見たように、暴走の元
useEffect(fn, [])最初に表示されたときだけ(+消えるときに後片づけ)一度繋いだら繋ぎ直さないもの(resize の購読など)
useEffect(fn, [a, b])a か b が前回と変わったときだけこれが基本。効果が引数に依存するとき

比べているのは、Object.is です。 再描画の深掘り回でやったのと同じ比較なので、オブジェクトや関数を依存に入れると、中身が同じでも毎回「変わった」と判定されます。 これは後で戻ってきます。

依存を嘘つきにすると、古い値を掴む

ここが、この節の山場です。

「effect が動きすぎるから、依存配列を減らそう」は、最もやってはいけない対処です。実際に見ます。

src/components/Stale.jsx を作ります。わざと依存を嘘にします。

import { useState, useEffect } from "react";

export default function Stale() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const id = setInterval(() => {
      console.log("いま見えている count:", count);
    }, 2000);

    return () => clearInterval(id);
  }, []);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>カウント: {count}</p>
      <button onClick={() => setCount(count + 1)}>+1</button>
    </div>
  );
}

App.jsx に足して、ボタンを5回押してください。 画面の数字は 5 になります。

2秒ごとに Console を見てください。

いま見えている count: 0
いま見えている count: 0
いま見えている count: 0

画面は 5 なのに、effect の中は 0 のままです。

なぜか。 effect の中の count は、「その effect が作られた回の描画に焼き付いた値」だからです。propsの深掘り回で setCount(count + 1) を2回書いても1しか増えなかったのと、まったく同じ理由です。

依存配列を [] にしたということは、React にこう言ったのと同じです。

「この effect は count を使っていません。だから作り直さなくていいです」

嘘です。 使っています。 React はその嘘を信じて、作り直しませんでした。 結果、最初の count(0)を掴んだままの effect が、ずっと動き続けています。

正しくは、こうです。

  useEffect(() => {
    const id = setInterval(() => {
      console.log("いま見えている count:", count);
    }, 2000);

    return () => clearInterval(id);
  }, [count]);

押すたびに、タイマーが張り直されます。 「無駄では?」と思うかもしれませんが、後片づけが正しく書いてあるので、増えません。 1本を張り直しているだけです。

Console はこうなります。

いま見えている count: 5
いま見えている count: 5

[スクリーンショット: 07_古い値を掴む.png] 画面のカウントが 5 なのに、Console には いま見えている count: 0 と出続けているところを、両方が写るように撮ってください。

eslint の警告を消さない

Vite の React テンプレートには、eslint-plugin-react-hooks が最初から入っています(ESLintとPrettierの回)。

壊れている版([])に戻して、別のターミナルで走らせてください。

bash
$ cd ~/reactlab
$ npx eslint src
  8:6  warning  React Hook useEffect has a missing dependency: 'count'.
                Either include it or remove the dependency array
                react-hooks/exhaustive-deps

押す前に、機械が教えてくれています。

検索すると、この警告を消す書き方が出てきます。

  }, []); // eslint-disable-line react-hooks/exhaustive-deps

これを書いた瞬間、あなたは「バグを、バグではないことにした」だけです。

警告は「依存が足りない」と言っているのであって、「うるさい」わけではありません。 警告が消えても、古い値を掴んでいる事実は1ミリも変わりません。 警告が出るということは、たいてい「effect の書き方が間違っている」か、「そもそも effect が要らない」のどちらかです。

警告を消したくなったときに、順番に試すのはこれです。

順やること
①その effect が本当に必要か、②に戻って疑う
②setCount(c => c + 1) のような関数型更新にして、依存そのものを消す
③依存を素直に全部書く(張り直されても、後片づけがあれば増えない)
④effect の中でしか使わない関数を、effect の中に移す(次の項)
⑤eslint-disable を書く ← ここまで来ることは、ほぼ無い

②の例を1つ。 ④の GoodTimer で setCount((c) => c + 1) と書いたのを思い出してください。あれを setCount(count + 1) と書いていたら、count を依存に入れる必要が出て、1秒ごとにタイマーを張り直すことになっていました。 関数型更新にすると、effect が count を読まなくなるので、依存から消えます。

関数を依存に入れると、毎回変わる

もう1つ、必ず当たる壁があります。

export default function Search({ keyword }) {
  const [items, setItems] = useState([]);

  const fetchItems = () => {
    console.log("取りに行く:", keyword);
  };

  useEffect(() => {
    fetchItems();
  }, [fetchItems]);

この effect は、描画のたびに必ず動きます。 中で setItems まで呼べば、無限ループになります。

理由は、再描画の深掘り回でやった Object.is です。

  • fetchItems は、コンポーネントが呼ばれるたびに新しく作られる関数です
  • 中身は同じでも、Object.is では別物です
  • だから毎回「依存が変わった」と判定され、effect が動き、setItems すればまた描画され、また新しい関数ができ……

解き方は、いくつかあります。 その中で、最初に試すべきは一番地味なものです。

その関数を、effect の中に移す。

  useEffect(() => {
    const fetchItems = () => {
      console.log("取りに行く:", keyword);
    };

    fetchItems();
  }, [keyword]);

関数が effect の中にあるので、依存に入れる必要がなくなりました。 代わりに、その関数が使っている keyword だけを依存に書きます。

外に置く中に移す
依存に何を書くか関数そのもの(毎回変わる)関数が使う値だけ(keyword)
結果描画のたびに動く(setItems すれば無限ループ)keyword が変わったときだけ動く
追加のフック要る要らない

「関数を使い回して、毎回変わらないようにする」道具も React にはあります。 ですが、それは別の回の話です。 この記事の範囲では、「中に移す」で全部片づきます。 そして実際、現場でもこれで足りる場面がほとんどです。

依存配列と戦い始めたら、「effect が大きすぎる」というサインです。 1つの effect に1つの目的。 2つのことをしているなら、useEffect を2つに割ってください。 割るのは自由です。


⑥ 競合状態 — 速く打つと、古い結果が勝つ

ここまでで「effect は要る場面が限られる」と分かりました。 その残った場面のうち、最も危ないのが通信です。

わざと再現する

検索ボックスを作ります。 わざと、遅いときと速いときがある偽のAPIを用意します。

src/fakeApi.js を新規作成します。

export function search(keyword) {
  // 短い言葉ほど時間がかかる、という意地の悪いAPI
  const delay = keyword.length <= 2 ? 2000 : 300;

  return new Promise((resolve) => {
    setTimeout(() => {
      resolve([`${keyword} の結果A`, `${keyword} の結果B`]);
    }, delay);
  });
}

「短い言葉ほど遅い」は、わざとです。 現実のAPIも、ネットワークの都合で「先に投げたものが後に返る」ことが普通にあります。 それを確実に再現するための細工です。

src/components/SearchBox.jsx を作ります。まず、壊れている版です。

import { useState, useEffect } from "react";
import { search } from "../fakeApi";

export default function SearchBox() {
  const [keyword, setKeyword] = useState("");
  const [results, setResults] = useState([]);

  useEffect(() => {
    if (keyword === "") {
      setResults([]);
      return;
    }

    console.log("投げた:", keyword);
    search(keyword).then((data) => {
      console.log("返ってきた:", keyword);
      setResults(data);
    });
  }, [keyword]);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <input
        value={keyword}
        onChange={(e) => setKeyword(e.target.value)}
        placeholder="検索"
      />
      <p>入力中: {keyword}</p>
      <ul>
        {results.map((r, i) => (
          <li key={i}>{r}</li>
        ))}
      </ul>
    </div>
  );
}

App.jsx に import SearchBox from "./components/SearchBox"; を足し、<SearchBox /> を並べます。

入力欄に ab と打って、すぐ続けて cde と打ってください(結果として abcde)。手早く打つのがコツです。

Console を見てください。

投げた: a
投げた: ab
投げた: abc
投げた: abcd
投げた: abcde
返ってきた: abc
返ってきた: abcd
返ってきた: abcde
返ってきた: a
返ってきた: ab

abcde の結果が返ったあとに、a と ab の結果が返っています。

画面を見てください。

入力中: abcde
・ab の結果A
・ab の結果B

入力欄には abcde と書いてあるのに、表示されているのは ab の検索結果です。

これが競合状態です。 「最後に投げたもの」ではなく、「最後に返ってきたもの」が画面に出ています。 どちらが先に返るかは、こちらでは決められません。 だから、こちらで「古いものは捨てる」と決めるしかありません。

本番でこれが起きると、原因の特定が非常に難しくなります。 速く打ったときだけ、たまに、違う結果が出るからです。 開発中の速い回線では、ほぼ再現しません。

[スクリーンショット: 08_競合状態.png] 入力欄が abcde なのに、結果が ab の結果 になっている画面と Console を、両方が写るように撮ってください。

直し方A — ignore フラグ

後片づけを使います。 「通信を止める」のではなく、「古い通信の結果を無視する」やり方です。

  useEffect(() => {
    if (keyword === "") {
      setResults([]);
      return;
    }

    let ignore = false;

    console.log("投げた:", keyword);
    search(keyword).then((data) => {
      if (ignore) {
        console.log("捨てた:", keyword);
        return;
      }
      console.log("採用:", keyword);
      setResults(data);
    });

    return () => {
      ignore = true;
    };
  }, [keyword]);

同じように、手早く打ってください。

投げた: abcde
採用: abcde
捨てた: a
捨てた: ab

古い結果が返ってきても、捨てられています。 画面は abcde の結果のままです。

なぜ効くのか。

順起きること
1a で effect が動く。その effect の中の ignore は false
2ab に変わる → React が、まず前回の後片づけを動かす → a の ignore が true になる
3ab の effect が動く。これは別の ignore 変数で、false
4遅れて a の結果が返る → 自分の ignore が true なので、何もしない

ignore は、effect が動くたびに新しく作られる変数です。 effect 1回ぶんに1つ。 だから「自分が古くなったか」を、それぞれが自分で知っています。 ③でやった「開始と終了を対にする」が、ここでも効いています。

直し方B — AbortController で、通信そのものを止める

A は結果を捨てるだけで、通信自体は最後まで走ります。 本物の fetch なら、途中で打ち切れます。

書き方の型はこうです。

  useEffect(() => {
    const controller = new AbortController();

    fetch(`/api/search?q=${encodeURIComponent(keyword)}`, {
      signal: controller.signal,
    })
      .then((res) => res.json())
      .then((data) => setResults(data))
      .catch((err) => {
        if (err.name === "AbortError") {
          console.log("中断した:", keyword);
          return;
        }
        console.error(err);
      });

    return () => {
      controller.abort();
    };
  }, [keyword]);

catch の中の if (err.name === "AbortError") を忘れないでください。 中断すると、fetch は失敗として扱われます。 これを書かないと、正常に中断しただけで「エラー」として画面に赤い文字が出ます。

この記事の偽APIは fetch ではないので、B は動きません。 型として覚えて、本物の通信を書くときに使ってください。 通信そのものの話は、本線の非同期処理の回とAPIを作る回にあります。

AとBの使い分けです。

A: ignore フラグB: AbortController
画面が正しくなるかなるなる
通信を止められるか止まらない(結果を捨てるだけ)止まる
どんな処理でも使えるか使える(何でも)対応しているものだけ(fetch など)
書く手間少ないAbortError の分岐が要る

迷ったら A から。 B は「サーバーに無駄な負荷をかけたくない」「大きなデータを引いている」ときに足します。


⑦ データ取得に useEffect を使わない

ここまで、⑥で競合状態を直しました。 では、これで「effect でデータを取る」書き方は完成でしょうか。

していません。 useEffect で通信を書くと、最低でもこれだけのことを、毎回自分で書くことになります。

面倒内容
読み込み中isLoading を持って、出し入れする(useStateの深掘り回でやった、矛盾する state の温床)
エラーerror を持って、次の取得のときに消す
競合状態⑥でやった ignore を、毎回書く
キャッシュ同じ画面を2回開くと、2回取りに行く。 前の結果は消えている
再取得タブを切り替えて戻ったとき、古いデータのままでいいのか
重複同じデータを2つの部品が欲しがると、2回通信する
ウォーターフォール親が取り終わってから子が取り始める。 直列に並んで、体感が遅くなる

1つの画面ならまだ書けます。 10画面になると、この7つを10回ずつ書くことになります。 そして、必ずどこかで抜けます。

だから、実務では「データ取得を useEffect で書かない」という選択が普通になりました。 React の公式ドキュメントも、データ取得の項で「フレームワークの仕組みか、専用のライブラリを使うことを検討せよ」と書いています。

具体的には、こういうものがあります。 この記事では入れません。名前を知っておくだけで十分です。

名前何をするか
TanStack Query(旧 React Query)上の7つを全部引き受ける、いちばん広く使われているもの
SWR同じ系統。より小さい
フレームワークの仕組みNext.js などが持っている、データを取る作法(SSRの回)

ただし、順番を間違えないでください。

先にライブラリを入れると、何が解決されたのかが分かりません。 この記事で ignore を自分で書いて、競合状態を自分の目で見たからこそ、「あれをやってくれる」の意味が分かります。 ライブラリは、問題を知ってから入れるものです。

そして、この記事の結論は変わりません。

  • ライブラリを入れても、useEffect が消えるわけではありません。 購読・タイマー・ブラウザAPIには、依然として必要です
  • 消えるのは「通信のための useEffect」だけです。ですが、それが useEffect の使用箇所の大半を占めています

つまずいたところ

useEffect を「onMount」だと思っていた

最初、useEffect(fn, []) を「画面に出たとき1回だけ動く」と覚えました。 この覚え方が、後の全部を壊しました。

「1回だけ」だと思っていたので、後片づけを書く理由が分かりませんでした。 「消えるときの処理なんて、ページを閉じるときにしか要らないだろう」と。③で {show && <WindowSize />} を作って、切り替えるたびに解除が走るのを見るまで、本気でそう思っていました。

[] は「1回だけ」ではありません。 「繋ぎ直す理由が無い」というだけです。 繋いだものは、消えるときに必ず外れます。

依存配列の警告を、半年間 disable で消していた

react-hooks/exhaustive-deps の警告が出るたびに、eslint-disable-line を書いていました。 「依存を足すと無限ループになるから、これが正しい対処だ」と思っていたのです。

無限ループになるのは、依存が足りないからではなく、effect の中で setState していたからでした。 足りないものを足したら壊れる、というのは「そもそも effect が要らない」というサインだったのに、警告のほうを黙らせていました。

⑤の表の①〜⑤を、順番に試すようになってから、eslint-disable を書くことはほぼ無くなりました。

「開発中だけAPIが2回叩かれる」を、StrictMode を外して解決した

Network タブに同じリクエストが2本並んでいるのを見て、main.jsx から <StrictMode> を外しました。 2本が1本になりました。 直った、と思いました。

直っていません。 StrictMode は「後片づけが無いぞ」と教えてくれていただけです。 教えてくれる人を追い出しただけでした。

そのあと、本番で「画面を行き来していると、だんだん重くなる」という報告が来ました。 購読を解除していなかったからです。 StrictMode は、それを最初の日に教えてくれていました。

競合状態を、再現できずに1週間放置した

「たまに違う結果が出る」という報告を受けて、何度試しても再現しませんでした。 開発機は速いので、必ず投げた順に返ってくるからです。

⑥の偽APIのように、「短い言葉ほど遅い」という細工を入れて、初めて100%再現しました。 再現しないバグは直せません。 「再現させるための細工を書く」というのが、最初に思いつかなかった手でした。 障害対応の回で「わざと壊す」とやったのと、同じ発想でした。

描画中の setState を、絶対にやってはいけないと思い込んでいた

②の直し方Bを見て、「これは禁止されている書き方では」と思いました。 無限ループの警告が出る書き方だと覚えていたからです。

禁止されているのは「条件なしに呼ぶこと」でした。if (userId !== prevUserId) のように、次の描画では通らなくなる条件が付いていれば、正しい書き方です。 公式が推奨している形でもあります。

ただし、これを覚えた直後に乱用して、読めないコンポーネントを作りました。 key で済むならそちらです。


後片づけ

この記事で使った ~/reactlab/ は、実験用です。

まず、ブラウザのタブを閉じるか再読み込みしてください。 ④で張ったタイマーが残っている可能性があります。 開発サーバーを止めても、ブラウザの中で動いているものは止まりません。

開発サーバーを止めます。 起動しているターミナルで Ctrl+C を押します。

bash
$ ss -tlnp | grep 5175

確認: 何も返らなければ、止まっています。

ポートを閉じます。

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

確認: 一覧に 5175/tcp が残っていなければ成功です。

プロジェクトを消します。

bash
$ du -sh ~/reactlab
$ rm -rf ~/reactlab
$ ls ~

確認: reactlab が消えていれば片づけ完了です。

本線のものが無事なことを、必ず確認してください。

bash
$ ls ~/react-demo/src
App.css  App.jsx  assets  components  index.css  main.jsx

~/react-demo/ は、この先の本線でも使うので消さないでください。

戻し方: もう一度試したくなったら、①の npm create vite@latest reactlab -- --template react からやるだけです。数分で戻せます。 node_modules だけ消して中身を残すなら rm -rf ~/reactlab/node_modules、戻すのは cd ~/reactlab && npm install です(npmの回)。


まとめ

  • useEffect は「描画のあとに何かする道具」ではない。 React の外にあるものと同期を取るための、最後の手段
  • 書いた瞬間に「同期を保つ」という難しい仕事が1つ増える。 だから、まず「要らないのでは」を疑う
  • 要らない① — 他の値から計算できる値を、effect + setState で作らない。 描画中に計算する。 描画が1回ぶん多く走る(古い値で一度描画される)のを防げる
  • 要らない② — props が変わったら state を戻す、は effect でやらない。 丸ごと捨てるなら key、一部だけなら描画中に if で直す
  • key が変われば、React はそれを別の部品として作り直す。 「消す処理」を書く必要がなくなる
  • 要らない③ — 「押したら◯◯する」は、イベントハンドラに書く。 effect は「押したこと」を知らない。 知っているのは「いま依存がこうなっている」だけ
  • だから「送信したら通知」を effect に書くと、関係ない state が変わっただけで通知が出る
  • 要らない④ — 親に伝えるために effect を使わない。 変えると決めた場所で、そのまま呼ぶ
  • 判断の基準は1つ。 「ユーザーの操作で起きること」=イベントハンドラ / 「表示されている間、こうであってほしい」=effect
  • 本当に要るのは4つだけ。 ブラウザAPI・購読・タイマー・ネットワーク。 外の世界が出てこないなら、出番ではない
  • 後片づけを書かないと、動かなくなるのではなく「多重に動く」。 タイマーが倍々に増え、通信が何十回も飛ぶ
  • addEventListener には removeEventListener、setInterval には clearInterval。 開始と終了が対になっていない effect は、たいてい間違っている
  • 後片づけは、ページを閉じるときだけでなく、コンポーネントが画面から消えるたびに動く
  • 開発中に effect が「動く → 後片づけ → もう一度動く」のは StrictMode。 バグではなく、後片づけの書き忘れを暴くための検査
  • 「開発中にAPIが2回叩かれる」を StrictMode を外して解決しない。 見えなくなるだけで、直っていない
  • 依存配列は3通り。 書かない=毎回(ほぼ使わない) / []=繋ぎ直す理由が無い / [a, b]=これが基本
  • 依存を嘘つきにしない。 消すと effect は動かなくなるが、代わりに古い値を掴んだまま動き続ける
  • react-hooks/exhaustive-deps の警告を eslint-disable で消さない。 警告が消えても、バグは消えない
  • 警告が出たら順に試す。 ① effect 自体を疑う → ② 関数型更新で依存を消す → ③ 素直に全部書く → ④ 関数を effect の中に移す
  • 関数を依存に入れると、毎回別物なので無限ループになる。 Object.is の比較だから
  • 解法は「その関数を effect の中に移す」。 依存に書くのは、関数ではなく、関数が使う値
  • 依存配列と戦い始めたら、effect が大きすぎるサイン。 1つの effect に1つの目的。割るのは自由
  • 速く打つと、古いリクエストの結果が新しい結果を上書きする(競合状態)。画面には「最後に投げたもの」ではなく「最後に返ってきたもの」が出る
  • 開発機は速いので、ほぼ再現しない。 再現させる細工を、自分で書く
  • 直し方A: ignore フラグ。 後片づけで ignore = true にして、古い結果を捨てる。 何にでも使える
  • 直し方B: AbortController。 通信そのものを止める。 AbortError を catch で分岐しないと、正常な中断がエラー表示になる
  • 結論として、データ取得に useEffect を使わない。 読み込み中・エラー・競合状態・キャッシュ・重複・ウォーターフォールを、毎回自分で書くことになる
  • 公式も、フレームワークの仕組みか専用ライブラリを勧めている(TanStack Query / SWR など)
  • ただし、先に入れない。 自分で ignore を書いて競合状態を見たあとでないと、何が解決されたのか分からない
  • ライブラリを入れても useEffect は消えない。 消えるのは通信のための effect だけ。 だが、それが大半を占めている

参考リンク


次に読む

この記事は 【深掘り】React の 5 / 24 本目です。

記事
← 前の記事useStateとuseReducer — 読み込み中なのにエラーもある
→ 次の記事useMemoとuseCallback — 付けるほど遅くなる

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

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

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

Frontend›React — Effects
  • 要らない useEffect を消す判断
  • 後片づけ・依存配列・競合状態

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

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

コメント

コメントする

目次