状態管理はライブラリの話ではない — Contextまで

Reactの状態管理。画面の部品に値のカードを配る共有の箱、配置を整える部品。

1段だけなら、何ともありません。 ですがあれは、これから起きることの予告でした。

前回: コンポーネントは見た目の部品ではない — propsと状態 作業場所はVMの中(Ubuntu)、確認はホストの Windows のブラウザです。前回作った ~/react-demo/ の続きです。

前回、App.jsx を4つのコンポーネントに割りました。そして最後に、こう書きました。

TaskList は onToggle を使っていません。TaskItem に渡すためだけに受け取っています。

この記事では、その1段を、まず3段にします。 わざとです。「途中のコンポーネントが、自分では一度も使わない props を書き写している」状態を、自分の目で見てもらうためです。

そのうえで、大事なのは次の一文です。

バケツリレーが起きた瞬間に、状態管理ライブラリを入れてはいけません。

インターネットで「React 状態管理」と検索すると、いきなりライブラリの名前が並びます。 ですが、バケツリレーの多くは、ライブラリを入れなくても消えます。 消えなかったぶんだけが、次の道具の出番です。

この記事は、その順番の記事です。①置き場所を見直す → ②Context → ③それでも足りなければライブラリ。 今日は②までで、③には行きません。行かない理由も書きます。

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

目次

この記事でわかること

  • バケツリレーは、階層が深いから起きるのではない。 状態の置き場所と、コンポーネントの組み立て方で起きる。だから、まず組み立て方で消せる
  • children は特別な propsであること。これを使うと、途中のコンポーネントが props を1つも受け取らずに済む場合がある
  • Context は「配線を省く道具」であって、「速くする道具」ではないこと。Context の値が変わると、それを読んでいるコンポーネントは memo を付けていても再レンダリングされる
  • useReducer は「状態の入れ物」ではなく「変え方の一覧表」だということ。Redux の考え方が React 本体に入ったもので、ライブラリではない
  • 「状態管理」と呼ばれているものは1つではないこと。サーバーから来たデータは、本当は状態ではなくキャッシュで、必要な道具がまったく違う

この記事でやること

  1. 前回の構成に階層を1つ足し、深い位置の部品が必要とする値を通して、バケツリレーを実際に起こす
  2. children で組み立て直し、途中のコンポーネントから props を全部消す
  3. useContext を入れ、map の中を通っていた値の受け渡しをやめる
  4. Console で再レンダリングの回数を数え、Context の落とし穴を目で見て、useMemo で直す
  5. useReducer に置き換え、増えてきた「タスクの変え方」を1つのファイルに集める

先に知る言葉

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

言葉意味
バケツリレー(prop drilling)途中のコンポーネントが、自分では使わない props を、下へ書き写していく状態
children開始タグと終了タグの間に書いたものが、そのまま子に渡る特別な props
Context途中の階層を飛ばして、下のどこからでも値を読めるようにする React 本体の仕組み
ProviderContext の値を配る側のタグ。この内側にいるコンポーネントだけが、その値を読める
再レンダリングReact がコンポーネントの関数をもう一度呼び、返ってきた見た目を前回と見比べること
memoprops が前回と同じなら、その再レンダリングを省いてよい、という印
useMemo計算結果(やオブジェクト)を、材料が変わるまで作り直さずに使い回す
reducer「いまの状態」と「何が起きたか」を受け取って、「次の状態」を返すだけの関数
action「何が起きたか」を表すオブジェクト。{ type: "added", title: "牛乳" } のような形
dispatchaction を reducer に送る関数。「これが起きました」と知らせる係
キャッシュ元が別の場所にあるデータの、手元の写し。放っておくと古くなる

① 準備 — 前回の続きから

VMの中で、前回のディレクトリに入ります。

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

src/components:
TaskForm.jsx  TaskItem.jsx  TaskList.jsx  TaskSummary.jsx

この4つが components/ に並んでいれば、前回の続きです。 出ないときは前回からやり直してください。

前回の後片づけで 5173番を閉じました。 開け直します。

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

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

5173/tcp の行が出れば準備完了です。開けずに進むと、起動は成功するのにブラウザは読み込み中のままになります。

起動します。

bash
$ npm run dev -- --host 0.0.0.0

ホストの Windows のブラウザで http://192.168.226.50:5173/(IPは自分の値に。分からなければ VM の中で ip a)を開き、前回のタスクリストが動いていることを確認してから先へ進んでください。

この記事の間は、起動したままで構いません。 保存するたびに、ブラウザが勝手に切り替わります。止め方はターミナルで Ctrl+C です。


② バケツリレーを、実際に起こす

機能を1つ足します。 「いま使っている人の名前を、タスク1件ごとに小さく出す」です。

現実にありそうな要求です。 共有のリストなら「誰が入れたか」は見たい情報です。

そして、この値の置き場所を考えてみてください。

  • 使う人の名前は、アプリ全体で1つです。タスクごとに違うものではありません
  • 画面の上(ヘッダー)でも出したい
  • 各タスクの行の下でも出したい

前回の判断基準に当てはめます。

状態は「それを使う全員の、いちばん近い共通の親」に置く。

ヘッダーと、タスクの行。その共通の親は App です。 だから user は App に置きます。ここまでは前回どおりで、間違っていません。

問題は、そこから先です。

階層を1つ足す

同時に、画面を組み立て直します。 ヘッダーと本体を分けます。

これから作るファイルは3つ、書き換えるファイルは3つです。

ファイル役割持つ状態
src/App.jsx(書き換え)tasks と user を持つtasks / user
src/components/Header.jsx(新規)見出しと「ログイン中」なし
src/components/Board.jsx(新規)本体を囲む枠なし
src/components/TaskMeta.jsx(新規)1件ごとの「担当・登録時刻」なし
src/components/TaskList.jsx(書き換え)一覧の枠なし
src/components/TaskItem.jsx(書き換え)1件分の行なし
src/index.css(書き換え)見た目—

src/components/TaskForm.jsx と src/components/TaskSummary.jsx は前回のまま、触りません。

src/components/TaskMeta.jsx(新規)

function TaskMeta({ task, user }) {
  return (
    <span className="meta">
      担当: {user} / 登録 {new Date(task.id).toLocaleTimeString()}
    </span>
  );
}

export default TaskMeta;

new Date(task.id) が動くのは、id を Date.now() で作っていたからです。Date.now() は「1970年1月1日から数えたミリ秒」を返します。それを new Date(...) に渡すと日時に戻り、toLocaleTimeString() で時刻の文字列になります。 id を時刻から作ったことが、たまたまここで役に立っただけです。本来 id は「見分けるためのもの」で、意味を持たせるべきではありません。(本番では、後の段階で出てくる UUID やデータベースの採番を使います)

src/components/TaskItem.jsx(丸ごと置き換え)

import TaskMeta from "./TaskMeta.jsx";

function TaskItem({ task, user, onToggle, onRemove }) {
  return (
    <li>
      <span
        onClick={() => onToggle(task.id)}
        className={task.done ? "done" : ""}
      >
        {task.title}
      </span>
      <button onClick={() => onRemove(task.id)}>削除</button>
      <TaskMeta task={task} user={user} />
    </li>
  );
}

export default TaskItem;

user を見てください。 TaskItem は user を1度も使っていません。 TaskMeta に渡すためだけに、受け取って、書き写しています。

src/components/TaskList.jsx(丸ごと置き換え)

import TaskItem from "./TaskItem.jsx";

function TaskList({ tasks, user, onToggle, onRemove }) {
  if (tasks.length === 0) {
    return <p className="empty">まだ何もありません。上の欄から追加してください。</p>;
  }

  return (
    <ul>
      {tasks.map((task) => (
        <TaskItem
          key={task.id}
          task={task}
          user={user}
          onToggle={onToggle}
          onRemove={onRemove}
        />
      ))}
    </ul>
  );
}

export default TaskList;

ここも同じです。 TaskList は user を使っていません。 書き写しているだけです。

src/components/Header.jsx(新規)

function Header({ user }) {
  return (
    <header className="header">
      <h1>やること</h1>
      <p className="who">ログイン中: {user}</p>
    </header>
  );
}

export default Header;

<h1> が App から、ここに移りました。

src/components/Board.jsx(新規)

これが、この節の主役です。

import TaskForm from "./TaskForm.jsx";
import TaskSummary from "./TaskSummary.jsx";
import TaskList from "./TaskList.jsx";

function Board({ tasks, user, onAdd, onToggle, onRemove }) {
  return (
    <div className="board">
      <TaskForm onAdd={onAdd} />
      <TaskSummary tasks={tasks} />
      <TaskList
        tasks={tasks}
        user={user}
        onToggle={onToggle}
        onRemove={onRemove}
      />
    </div>
  );
}

export default Board;

Board がやっていることを、声に出して読んでください。

「<div> で囲む」。それだけです。

それだけのために、props を5つ受け取っています。 そして5つとも、自分では1つも使わずに、下へ渡しています。

src/App.jsx(丸ごと置き換え)

import { useState } from "react";
import Header from "./components/Header.jsx";
import Board from "./components/Board.jsx";

function App() {
  const [tasks, setTasks] = useState([]);
  const [user, setUser] = useState("たろう");

  const addTask = (title) => {
    setTasks([...tasks, { id: Date.now(), title, done: false }]);
  };

  const toggleTask = (id) => {
    setTasks(tasks.map((t) => (t.id === id ? { ...t, done: !t.done } : t)));
  };

  const removeTask = (id) => {
    setTasks(tasks.filter((t) => t.id !== id));
  };

  return (
    <div className="app">
      <Header user={user} />
      <Board
        tasks={tasks}
        user={user}
        onAdd={addTask}
        onToggle={toggleTask}
        onRemove={removeTask}
      />
      <button
        className="switch"
        onClick={() => setUser(user === "たろう" ? "はなこ" : "たろう")}
      >
        使う人を切り替える
      </button>
    </div>
  );
}

export default App;

「使う人を切り替える」ボタンを付けたのは、user が変わったときに何が起きるかを、あとで見るためです。

src/index.css(丸ごと置き換え)

body {
  font-family: sans-serif;
  margin: 2rem;
  line-height: 1.7;
}

.done {
  text-decoration: line-through;
  color: #888;
}

li span {
  cursor: pointer;
}

.empty {
  color: #888;
}

.header {
  border-bottom: 1px solid #ddd;
  margin-bottom: 1rem;
}

.who {
  color: #666;
  font-size: 0.9rem;
  margin-top: -0.5rem;
}

.board {
  border: 1px solid #ddd;
  border-radius: 6px;
  padding: 1rem;
}

.meta {
  display: block;
  color: #999;
  font-size: 0.8rem;
  cursor: auto;
}

.switch {
  margin-top: 1rem;
}

動かして、数える

ブラウザを見てください。 タスクを2〜3件追加すると、各行の下に「担当: たろう / 登録 14:32:07」のような行が出ます。「使う人を切り替える」を押すと、全部が「はなこ」に変わります。

動きます。 動くのですが、user がどこを通ったかを数えてください。

App          user を持っている        ← 出発点
└── Board    user を受け取る          ← 使わない。書き写す
    └── TaskList   user を受け取る    ← 使わない。書き写す
        └── TaskItem  user を受け取る ← 使わない。書き写す
            └── TaskMeta              ← ここで初めて使う

間に3つ、自分では使わないコンポーネントがいます。

[スクリーンショット: 01_バケツリレー.png] VS Code で Board.jsx TaskList.jsx TaskItem.jsx の3つを開き、それぞれに user という文字が書かれているのが分かる形で撮ってください。

何が困るのか、具体的に書きます。

いま起きていること将来どうなるか
user を1つ足すのに、4ファイル直したprops を1つ増やすたびに、通り道の全ファイルを直す
Board の props が5個あるBoard を読んでも、何をする部品なのか分からない(囲むだけなのに)
TaskMeta の user がどこから来たか4ファイル遡らないと分からない
Board を別の画面で使い回したい5つの props を全部用意しないと使えない。囲むだけの部品なのに

これがバケツリレーです。「動かない」わけではありません。「変えるのが重い」だけです。そして、変えるのが重いものは、そのうち変えられなくなります。


③ 手を出す①:置き場所ではなく、組み立て方を変える

ここで Context に飛びつく前に、やることがあります。

もう一度 Board を見てください。

Board は <div> で囲むだけの部品です。 中身が何であるかを、Board が知っている必要は、本当にあるでしょうか。

ありません。 中身を決めているのは App です。Board は「渡されたものを、枠の中に置く」だけでいい。

それを書く方法が children です。

children とは何か

JSX の、開始タグと終了タグの間に書いたものが、子に children という名前の props で渡ります。

// 親がこう書くと
<Board>
  <p>なかみ</p>
</Board>

// 子ではこう受け取れる
function Board({ children }) {
  return <div className="board">{children}</div>;
}

children は特別な名前で、React が自動で入れてくれます。 自分で children={...} と書く必要はありません。

重要なのは、ここです。 <p>なかみ</p> を作ったのは App です。Board ではありません。 だから、その <p> が必要とする props は、App の中で解決済みです。Board を通す必要がありません。

src/components/Board.jsx(丸ごと置き換え)

function Board({ children }) {
  return <div className="board">{children}</div>;
}

export default Board;

import が全部消えました。props も5個から1個になりました。

src/App.jsx(丸ごと置き換え)

import { useState } from "react";
import Header from "./components/Header.jsx";
import Board from "./components/Board.jsx";
import TaskForm from "./components/TaskForm.jsx";
import TaskSummary from "./components/TaskSummary.jsx";
import TaskList from "./components/TaskList.jsx";

function App() {
  const [tasks, setTasks] = useState([]);
  const [user, setUser] = useState("たろう");

  const addTask = (title) => {
    setTasks([...tasks, { id: Date.now(), title, done: false }]);
  };

  const toggleTask = (id) => {
    setTasks(tasks.map((t) => (t.id === id ? { ...t, done: !t.done } : t)));
  };

  const removeTask = (id) => {
    setTasks(tasks.filter((t) => t.id !== id));
  };

  return (
    <div className="app">
      <Header user={user} />
      <Board>
        <TaskForm onAdd={addTask} />
        <TaskSummary tasks={tasks} />
        <TaskList
          tasks={tasks}
          user={user}
          onToggle={toggleTask}
          onRemove={removeTask}
        />
      </Board>
      <button
        className="switch"
        onClick={() => setUser(user === "たろう" ? "はなこ" : "たろう")}
      >
        使う人を切り替える
      </button>
    </div>
  );
}

export default App;

保存してブラウザを見てください。見た目は1ミリも変わりません。

変わったのは、通り道です。

App
└── Board          ← props は children だけ。user を知らない
    └── TaskList   ← user を受け取る(使わない)
        └── TaskItem   ← user を受け取る(使わない)
            └── TaskMeta   ← 使う

素通りしていた3つが、2つに減りました。 ライブラリは1つも入れていません。

これが、状態管理の話で最初にやるべきことです。 「深い階層を、どうやって飛び越えるか」を考える前に、「そもそも深くする必要があるか」を疑う。 囲むだけの部品・レイアウトの部品は、children にすると props がゼロになります。

なぜ、これで全部は消えないのか

同じ手を TaskList にも使えないでしょうか。 つまり、App が TaskItem を作って TaskList に children として渡す。

できます。ですが、やりません。

  • tasks.map() は「一覧を出す」ことそのものです。それを App に持っていくと、App が一覧の作り方を知ることになります。 前回、わざわざ TaskList に閉じ込めたものが戻ってきます
  • TaskItem は map の中で作られます。 「何個できるか」がデータ次第なので、App の JSX に書き並べることができません

children で消せるのは「中身が固定で、囲むだけ」の階層までです。繰り返しの中を通っていく props は、これでは消せません。

ここで初めて、Context の出番です。順番を守った結果として、必要になりました。


④ 手を出す②:useContext

Context は、こう説明されます。

上のほうで「この値を配ります」と宣言すると、その内側にいるコンポーネントは、階層をいくつ挟んでいても、直接その値を読める。

props の受け渡しが「手渡し」なら、Context は「部屋に流れている放送」です。途中の人が中継する必要はありません。

src/contexts/UserContext.js(新規)

まずディレクトリを作ります。

bash
$ mkdir -p ~/react-demo/src/contexts
import { createContext } from "react";

export const UserContext = createContext("名無し");

3行です。 説明することが3つあります。

  • 拡張子が .jsx ではなく .js です。JSX を1文字も書いていないからです。.jsx にしても動きますが、揃えておくと「このファイルは見た目を作らない」と一目で分かります
  • export default ではなく、名前を付けた export です。1つのファイルに Context を複数置くことがあるためです。だから読み込む側は import { UserContext } from ... と、波かっこが要ります
  • createContext("名無し") の "名無し" は「既定値」です。これが使われるのは、後で出てくる Provider の外側で読んだときだけです。ここが、最初のつまずきポイントなので、あとで戻ってきます

src/App.jsx(丸ごと置き換え)

import { useState } from "react";
import { UserContext } from "./contexts/UserContext.js";
import Header from "./components/Header.jsx";
import Board from "./components/Board.jsx";
import TaskForm from "./components/TaskForm.jsx";
import TaskSummary from "./components/TaskSummary.jsx";
import TaskList from "./components/TaskList.jsx";

function App() {
  const [tasks, setTasks] = useState([]);
  const [user, setUser] = useState("たろう");

  const addTask = (title) => {
    setTasks([...tasks, { id: Date.now(), title, done: false }]);
  };

  const toggleTask = (id) => {
    setTasks(tasks.map((t) => (t.id === id ? { ...t, done: !t.done } : t)));
  };

  const removeTask = (id) => {
    setTasks(tasks.filter((t) => t.id !== id));
  };

  return (
    <UserContext.Provider value={user}>
      <div className="app">
        <Header user={user} />
        <Board>
          <TaskForm onAdd={addTask} />
          <TaskSummary tasks={tasks} />
          <TaskList tasks={tasks} onToggle={toggleTask} onRemove={removeTask} />
        </Board>
        <button
          className="switch"
          onClick={() => setUser(user === "たろう" ? "はなこ" : "たろう")}
        >
          使う人を切り替える
        </button>
      </div>
    </UserContext.Provider>
  );
}

export default App;

3箇所だけ変わっています。

  1. import { UserContext } ... が増えた
  2. 全体を <UserContext.Provider value={user}> で囲んだ
  3. <TaskList ... /> から user={user} が消えた

Header には user={user} を残しました。 わざとです。

Header は App の直接の子です。1段渡すだけなら、props のほうが読みやすい。 「どこから来た値か」がその場で見えるからです。Context にすると、それが見えなくなります。 Context は「深くて困っているところ」にだけ使う。 全部 Context にすると、今度は「この値は誰が配っているのか」が分からなくなります。

<UserContext.Provider> という書き方について。 React 19 からは <UserContext> とだけ書いても Provider として動きます。ですが .Provider は今も動き、React 18 でも動きます。 他人のコードで見るのは、まだ .Provider のほうが圧倒的に多いので、この記事ではこちらで書きます。

src/components/TaskList.jsx(丸ごと置き換え)

import TaskItem from "./TaskItem.jsx";

function TaskList({ tasks, onToggle, onRemove }) {
  if (tasks.length === 0) {
    return <p className="empty">まだ何もありません。上の欄から追加してください。</p>;
  }

  return (
    <ul>
      {tasks.map((task) => (
        <TaskItem
          key={task.id}
          task={task}
          onToggle={onToggle}
          onRemove={onRemove}
        />
      ))}
    </ul>
  );
}

export default TaskList;

src/components/TaskItem.jsx(丸ごと置き換え)

import TaskMeta from "./TaskMeta.jsx";

function TaskItem({ task, onToggle, onRemove }) {
  return (
    <li>
      <span
        onClick={() => onToggle(task.id)}
        className={task.done ? "done" : ""}
      >
        {task.title}
      </span>
      <button onClick={() => onRemove(task.id)}>削除</button>
      <TaskMeta task={task} />
    </li>
  );
}

export default TaskItem;

user という文字が、この2ファイルから完全に消えました。

src/components/TaskMeta.jsx(丸ごと置き換え)

import { useContext } from "react";
import { UserContext } from "../contexts/UserContext.js";

function TaskMeta({ task }) {
  const user = useContext(UserContext);

  return (
    <span className="meta">
      担当: {user} / 登録 {new Date(task.id).toLocaleTimeString()}
    </span>
  );
}

export default TaskMeta;

useContext(UserContext) の1行で、user が手に入りました。 誰からも渡されていません。

../contexts/ の .. は「1つ上のディレクトリ」です。TaskMeta.jsx は src/components/ にいるので、.. で src/ に上がり、そこから contexts/ に入ります。 ./contexts/... と書くと src/components/contexts/ を探して失敗します。

確かめる

ブラウザで、タスクを3件追加してください。 各行の下に「担当: たろう」が出ます。

「使う人を切り替える」を押してください。 3件とも一斉に「はなこ」に変わります。

[スクリーンショット: 02_Contextで切り替わる.png] タスクが3件あり、全部の「担当:」が「はなこ」になっている画面を撮ってください。上のヘッダーの「ログイン中: はなこ」も一緒に写る形で。

落とし穴その1:Provider の外で読むと、黙って既定値になる

createContext("名無し") の "名無し" を思い出してください。

試しに、App.jsx の <UserContext.Provider ...> の行と、閉じる </UserContext.Provider> の行を、一時的に消してみてください。

エラーは出ません。 画面には「担当: 名無し」と出ます。

これが Context の一番厄介なところです。 「Provider を書き忘れた」と「配られている値がたまたま既定値だった」を、React は区別しません。 エラーも警告も出ないまま、既定値が表示され続けます。

だから、既定値には「明らかにおかしいと分かる値」を入れておくのが安全です。"名無し" はまさにそれで、画面に「名無し」が出たら Provider を疑う、と決めておけます。

消した2行を、戻してください。


⑤ Context の本当の落とし穴 — 誰が再レンダリングされるのか

ここが、この記事で一番技術的に重要な節です。

Context は便利なので、つい「全部これでいいのでは」と思います。 ですが、Context には値段があります。

Context の値が変わると、その Context を useContext で読んでいるコンポーネントは、全部、必ず再レンダリングされます。 途中に「省略してよい」という印(memo)が付いていても、素通りして再レンダリングされます。

言葉で読んでも実感しないので、Console で数えます。

準備:配るものを増やす

現実的な変更をします。 名前だけでなく、「切り替える関数」も配りたくなったとします。ヘッダーの中に切り替えボタンを置きたい、といった話です。

value に2つ以上入れたいときは、オブジェクトにします。

src/contexts/UserContext.js を丸ごと置き換えます。

import { createContext } from "react";

export const UserContext = createContext({
  user: "名無し",
  setUser: () => {},
});

src/App.jsx の Provider の行だけを、こう変えます(他は触りません)。

    <UserContext.Provider value={{ user, setUser }}>

value={{ user, setUser }} の波かっこが2重なのは、外側が「ここから JavaScript の式」の合図、内側がオブジェクトです。前回出てきた話です。

数える仕掛けを入れる

src/components/TaskMeta.jsx を丸ごと置き換えます。

import { memo, useContext } from "react";
import { UserContext } from "../contexts/UserContext.js";

function TaskMeta({ task }) {
  const { user } = useContext(UserContext);

  console.log("TaskMeta を描画:", task.title);

  return (
    <span className="meta">
      担当: {user} / 登録 {new Date(task.id).toLocaleTimeString()}
    </span>
  );
}

export default memo(TaskMeta);

2つ、新しいものが入りました。

  • console.log(...) — 描画されるたびに開発者ツールの Console に1行出ます
  • export default memo(TaskMeta); — 「props が前回と同じなら、この関数を呼ばなくていい」という印です

TaskMeta が受け取る props は task だけです。すでに画面にあるタスクの task は、新しいタスクを足しても変わりません。

なぜ変わらないのか。 addTask は setTasks([...tasks, 新しいの]) です。[...tasks] は配列を新しく作りますが、中に入っている1件1件のオブジェクトは、元と同じものがそのまま入ります。 だから既存の3件の task は「前回と同じもの」です。memo は、これを見て「省略していい」と判断できるはずです。

つまり、期待はこうです。

タスクを4件目に追加したとき、Console に出るのは「TaskMeta を描画: 4件目」の1行だけのはず。

実際にやる

ブラウザで F12 を押し、Console タブを開いてください。 ゴミ箱のアイコン(Clear console)で一度きれいにします。

タスクを3件追加します。そのあとConsole をもう一度きれいにして、4件目を追加してください。

[スクリーンショット: 03_全部再描画される.png] 4件目を追加した直後の Console を撮ってください。「TaskMeta を描画:」が4件分(+StrictModeで2倍)出ているのが分かる形で。

4件分、全部出ます。 memo を付けたのに、既存の3件も描画されています。

同じ行が2回ずつ出ます。 これは異常ではありません。 前回出てきた <StrictMode> が、開発中だけ、わざと関数を2回呼んでいるからです。数えるときは「種類」を見てください。

なぜ memo が効かなかったのか

memo が比べるのは props です。task は同じでした。 にもかかわらず再描画されたのは、useContext で読んでいる値が変わったからです。

そして、値は変わっていました。 user の文字は「たろう」のままなのに、です。

value={{ user, setUser }}

この { user, setUser } は、App が再描画されるたびに、新しく作られるオブジェクトです。 中身は同じでも、「別のオブジェクト」です。JavaScript の回でやった「見た目が同じでも同一とは限らない」が、ここで効いています。 React は「値が変わった」と判断し、この Context を読んでいる全員を描き直します。

直す:useMemo

「材料が変わらないなら、同じオブジェクトを使い回す」と書きます。それが useMemo です。

src/App.jsx を丸ごと置き換えます。

import { useState, useMemo } from "react";
import { UserContext } from "./contexts/UserContext.js";
import Header from "./components/Header.jsx";
import Board from "./components/Board.jsx";
import TaskForm from "./components/TaskForm.jsx";
import TaskSummary from "./components/TaskSummary.jsx";
import TaskList from "./components/TaskList.jsx";

function App() {
  const [tasks, setTasks] = useState([]);
  const [user, setUser] = useState("たろう");

  const addTask = (title) => {
    setTasks([...tasks, { id: Date.now(), title, done: false }]);
  };

  const toggleTask = (id) => {
    setTasks(tasks.map((t) => (t.id === id ? { ...t, done: !t.done } : t)));
  };

  const removeTask = (id) => {
    setTasks(tasks.filter((t) => t.id !== id));
  };

  const userValue = useMemo(() => ({ user, setUser }), [user]);

  return (
    <UserContext.Provider value={userValue}>
      <div className="app">
        <Header user={user} />
        <Board>
          <TaskForm onAdd={addTask} />
          <TaskSummary tasks={tasks} />
          <TaskList tasks={tasks} onToggle={toggleTask} onRemove={removeTask} />
        </Board>
        <button
          className="switch"
          onClick={() => setUser(user === "たろう" ? "はなこ" : "たろう")}
        >
          使う人を切り替える
        </button>
      </div>
    </UserContext.Provider>
  );
}

export default App;

useMemo(() => ({ user, setUser }), [user]) の読み方です。

部分意味
() => ({ user, setUser })作り方。オブジェクトを返す関数
[user]材料の一覧。この中身が変わったときだけ、作り直す
返ってくるもの作り直していないときは、前回とまったく同じオブジェクト

() => ({ ... }) のかっこに注意してください。() => { ... } と書くと、{} が「関数の本体」だと解釈され、何も返さない関数になります。 オブジェクトを返したいときは、( ) で囲みます。 ここは本当によく間違えます。

setUser を材料に入れていないのは、useState が返す set... は、React が「毎回同じもの」を保証しているからです。変わらないので、書く必要がありません。

もう一度、数える

Console をきれいにして、5件目を追加してください。

「TaskMeta を描画: 5件目」だけが出ます(StrictMode で2回)。既存の4件は出ません。

[スクリーンショット: 04_useMemo後.png] 5件目を追加した直後の Console を撮ってください。1種類しか出ていないのが分かる形で。

memo が、やっと効きました。

それでも、避けられないこと

Console をきれいにして、今度は「使う人を切り替える」を押してください。

5件とも、全部出ます。

これは正しい動作です。 user が本当に変わったので、user を表示している5件は描き直す必要があります。

ですが、ここから大事な結論が出ます。

memo を付けても、Context の値が変わったら止められません。 だから、「よく変わる値」と「めったに変わらない値」を、1つの Context に混ぜてはいけません。

具体例で言います。

// ❌ やってはいけない
<AppContext.Provider value={{ user, theme, tasks, searchText }}>

searchText(入力欄の文字)は、1文字打つたびに変わります。 これを混ぜると、user しか読んでいないコンポーネントまで、1文字ごとに再描画されます。

対処は2つです。

やり方内容
Context を分けるUserContext と SearchContext を別々に作る。読んでいる側は、変わったほうだけ再描画される
そもそも Context に入れないsearchText が1〜2段先で済むなら、props のほうが安い

これが「Context は速くする道具ではない」の意味です。 Context が減らすのは「書く手間」だけで、再レンダリングの量は、むしろ増えることがあります。 状態管理ライブラリ(後述)の多くが売りにしているのは、まさにここです。「Context だと全員が描き直されるところを、必要な人だけにする」。

確かめ終わったので、console.log の行を消してください。 src/components/TaskMeta.jsx から、この1行だけ削除します。

  console.log("TaskMeta を描画:", task.title);

memo(TaskMeta) は残してください。 消しても動きますが、残しておいて損はありません。


⑥ useReducer — 変え方が増えてきたら

機能を2つ足します。

  • 「全部完了にする」
  • 「完了したものをまとめて消す」

いまのやり方だと、App にこうなります。

  const addTask = (title) => { setTasks(...); };
  const toggleTask = (id) => { setTasks(...); };
  const removeTask = (id) => { setTasks(...); };
  const completeAll = () => { setTasks(...); };
  const clearDone = () => { setTasks(...); };

setTasks を呼ぶ場所が5箇所になりました。そして、これはまだ増えます。 並べ替え、名前の編集、期限の設定。10箇所、15箇所になります。

そのとき何が困るか。

「tasks が、いつ、どう変わりうるか」を知るために、App を上から下まで読むことになります。 そして setTasks を呼ぶ場所が増えるほど、「1箇所だけ書き忘れる」が起きます。

useReducer は、この5つを、1つのファイルの1つの関数に集めます。

reducer とは、ただの関数です

function reducer(いまの状態, 何が起きたか) {
  return 次の状態;
}

これだけです。React も DOM も出てきません。 useState も使いません。 ただ、値を受け取って、値を返すだけの関数です。

src/tasksReducer.js(新規)

export const initialTasks = [];

export function tasksReducer(tasks, action) {
  switch (action.type) {
    case "added":
      return [...tasks, { id: Date.now(), title: action.title, done: false }];

    case "toggled":
      return tasks.map((t) =>
        t.id === action.id ? { ...t, done: !t.done } : t
      );

    case "removed":
      return tasks.filter((t) => t.id !== action.id);

    case "completedAll":
      return tasks.map((t) => ({ ...t, done: true }));

    case "clearedDone":
      return tasks.filter((t) => !t.done);

    default:
      throw new Error("知らない action.type です: " + action.type);
  }
}

switch の中身は、いままで App に散らばっていたものと、1文字も違いません。 場所が変わっただけです。

説明が3つあります。

  • action は、ただのオブジェクトです。type に「何が起きたか」、それ以外に必要な情報を入れます。 { type: "added", title: "牛乳" } のように
  • default で throw しているのは、わざとです。"toggeld" のように打ち間違えたとき、何も起きずに黙って無視されるのが一番困ります。 画面に赤いエラーが出たほうが、100倍ましです
  • initialTasks も一緒に置いたのは、「この状態の初期値はこれ」がファイルの中で完結するためです

action.type の文字を、なぜ "added"(過去形)にしているのか。 "add" だと「追加しろ」という命令に読めます。 ですが、dispatch が伝えているのは「追加が起きた」という事実です。どう反映するかを決めるのは reducer 側です。 命令ではなく報告。 前回の「子は出来事を報告するだけ」と、まったく同じ考え方です。

src/App.jsx(丸ごと置き換え・これが最終形)

import { useReducer, useState, useMemo } from "react";
import { UserContext } from "./contexts/UserContext.js";
import { tasksReducer, initialTasks } from "./tasksReducer.js";
import Header from "./components/Header.jsx";
import Board from "./components/Board.jsx";
import TaskForm from "./components/TaskForm.jsx";
import TaskSummary from "./components/TaskSummary.jsx";
import TaskList from "./components/TaskList.jsx";

function App() {
  const [tasks, dispatch] = useReducer(tasksReducer, initialTasks);
  const [user, setUser] = useState("たろう");

  const userValue = useMemo(() => ({ user, setUser }), [user]);

  return (
    <UserContext.Provider value={userValue}>
      <div className="app">
        <Header user={user} />
        <Board>
          <TaskForm onAdd={(title) => dispatch({ type: "added", title })} />
          <TaskSummary tasks={tasks} />
          <TaskList
            tasks={tasks}
            onToggle={(id) => dispatch({ type: "toggled", id })}
            onRemove={(id) => dispatch({ type: "removed", id })}
          />
          <div className="bulk">
            <button onClick={() => dispatch({ type: "completedAll" })}>
              全部完了にする
            </button>
            <button onClick={() => dispatch({ type: "clearedDone" })}>
              完了したものを消す
            </button>
          </div>
        </Board>
        <button
          className="switch"
          onClick={() => setUser(user === "たろう" ? "はなこ" : "たろう")}
        >
          使う人を切り替える
        </button>
      </div>
    </UserContext.Provider>
  );
}

export default App;

App から setTasks が消えました。 tasks をどう変えるかを書いた場所が、App に1行もありません。

useReducer(tasksReducer, initialTasks) が返すのは2つです。

返ってくるもの意味
tasksいまの状態。useState の1つめと同じように使う
dispatch「何が起きたか」を reducer に送る関数

useState との対応は、こうです。

useStateuseReducer
状態taskstasks
変える手段setTasks(新しい値)dispatch({ type: "...", ... })
変え方が書いてある場所呼び出す側に散らばるreducer 1箇所

src/index.css に1つ足す

末尾に追記してください(全文は②のものに、この1つが増えるだけです)。

.bulk {
  margin-top: 1rem;
  display: flex;
  gap: 0.5rem;
}

確かめる

ブラウザで、タスクを3件追加してください。

  • 「全部完了にする」 を押す → 3件全部に取り消し線が付き、「残り 0 件 / 全 3 件」になる
  • 「完了したものを消す」 を押す → 3件とも消え、「まだ何もありません」に戻る

[スクリーンショット: 05_useReducer後.png] タスクが3件あり、「全部完了にする」を押した直後の画面を撮ってください。3件とも取り消し線で、「残り 0 件 / 全 3 件」が見える形で。

useReducer を、いつ使うか

useState を捨てて全部 reducer にする、という話ではありません。

状況使うもの
状態が1つで、変え方も1つ(入力中の文字など)useState。reducer にすると、書く量が増えるだけ
1つの状態を、3〜4通り以上のやり方で変えるuseReducer
「AとBを同時に変える」が何度も出てくるuseReducer。1つの action にまとめられる

user を useState のまま残したのは、そのためです。変え方が1つしかないものを reducer にしても、何も良くなりません。

useReducer はライブラリではありません。React 本体の機能です。 そして、Redux という状態管理ライブラリの考え方が、そのまま React 本体に入ったものです。ここまで書けていれば、Redux を読むときに新しく覚えることは、ほとんどありません。 「ライブラリを入れる前にやることがある」の、2つめの答えがこれです。


⑦ 「状態管理」と呼ばれているものは、1つではない

ここまで扱ってきたのは、全部「画面の状態」です。タスクの一覧も、使っている人の名前も、この画面の中だけで生まれて、この画面の中だけで消えます。

ですが、実際のアプリで一番多い「状態」は、これではありません。

サーバーから取ってきたデータです。

そして、それを useState に入れた瞬間に、まったく別の問題が始まります。

// よくある書き方。そして、ここから苦しくなる
const [tasks, setTasks] = useState([]);
// どこかで fetch して setTasks(結果)

何が困るのか。

  • このデータの持ち主は、自分ではありません。サーバーです。 手元にあるのは写しです
  • 写しは、古くなります。 他の人がスマホから1件足したら、この画面の tasks は、その瞬間に嘘になります
  • 「読み込み中」「失敗した」という状態も、自分で持つことになります
  • 2つの画面が同じデータを必要としたら、2回取りに行くのか、共有するのかを決めることになります
  • タブを切り替えて戻ってきたとき、取り直すのかを決めることになります

これは「状態をどこに置くか」の問題ではありません。 キャッシュの問題です。

useState は、キャッシュの道具ではありません。 Context も、Redux も、Zustand も、キャッシュの道具ではありません。 「入れ物」しか用意してくれないので、「いつ取り直すか」は全部自分で書くことになります。

だから、こう整理します。

種類例持ち主使う道具
画面の状態開いている / 閉じている、選択中のタブ、並び順自分useState / useReducer / Context、足りなければ Zustand など
フォームの状態入力中の文字、検証エラー自分(一時的)useState、複雑なら React Hook Form
サーバーの状態(実体はキャッシュ)一覧、ユーザー情報、検索結果サーバーTanStack Query / SWR
URL の状態検索語、ページ番号、絞り込み条件URLルーター(次の段階以降で扱います)

この4つを混ぜて1つの箱に入れるから、「状態管理が難しい」という話になります。分けてしまえば、それぞれは大した話ではありません。

URL の状態について、1つだけ。 「絞り込み条件」を useState に入れると、その画面を人に送れません。 URL にリロードしても消えない情報として持たせるべきものがあります。 useState に入れる前に「これ、リンクで共有したい情報ではないか」と聞いてください。

この記事では、まだ fetch をこの画面に繋いでいません。 サーバーを作るのが次の段階だからです。サーバーの状態の話は、繋いだあとで、本当に困ってからやります。


⑧ ライブラリの名前と、それぞれ何を解く道具なのか

名前だけは知っておいたほうがいいので、並べます。 この記事では1つも入れません。

名前何を解く道具か出番
Redux ToolkituseReducer を、アプリ全体に広げたもの。 変更の種類を1箇所に集め、「いつ・何が起きたか」を全部追える大人数、複雑な画面、バグの再現が難しいとき
Zustand状態をコンポーネントの外に置く。 Context の書き方の面倒さと、「読んでいる人全員が再描画される」を小さくするContext が増えすぎ、⑤の問題が出てきたとき
Jotai(Recoil は 2025年1月にリポジトリがアーカイブされ、開発終了)状態を小さい単位に割り、必要な人だけを描き直す同上。考え方の好みで分かれる
TanStack Queryサーバーのデータのキャッシュ。 取り直し、読み込み中、失敗、同じデータの共有を全部やる⑦の「サーバーの状態」を扱い始めたら
React Hook Form入力欄が多いフォームの、値と検証入力欄が10個を超えてきたら

注目してほしいのは、この表の縦の並びではなく、横です。

上の3つと、TanStack Query は、競合しません。 「Redux と TanStack Query、どっちを使う?」という質問は、成立していません。 解いている問題が違うからです。 実際、両方入っているプロジェクトは普通にあります。

「React 状態管理 おすすめ」で出てくる比較記事の多くが、この4つ目を混ぜて並べています。 並んでいるからといって、選ぶものだとは限りません。

なぜ、この記事では入れないのか

理由を3つ、正直に書きます。

  1. まだ困っていません。 ②で起きたバケツリレーは、③の children と④の Context で消えました。残っている問題がありません
  2. サーバーからデータを取っていません。 ライブラリの多くが解く問題の本命は⑦のキャッシュです。サーバーが無い段階で入れても、何を解いているか分かりません
  3. 入れると、区別が付かなくなります。 「React の機能」と「そのライブラリの機能」の境目が、最初のうちは見えません。 後から別のライブラリに移るときや、他人のコードを読むときに、何がどっちだったか分からなくなります

前回と同じ結論です。 props で足りなくなってから Context。Context で足りなくなってからライブラリ。 そして「足りなくなった」は、自分の手が重くなって初めて分かります。 記事を読んで分かるものではありません。


⑨ 状態を増やしすぎない

この記事の最後に、前回の一文をもう一度置きます。

計算で出せるものを、状態にしない。

前回は「残り件数」でした。 前回のリフトアップの節に書いたとおりなので、繰り返しません。

Context と reducer を覚えたあとは、これがもっと危なくなります。

// ❌ よくある間違い
const [tasks, setTasks] = useState([]);
const [doneTasks, setDoneTasks] = useState([]);       // tasks から出せる
const [remaining, setRemaining] = useState(0);        // tasks から出せる
const [isEmpty, setIsEmpty] = useState(true);         // tasks から出せる

この4つを一致させ続ける責任が、全部自分に来ます。 そして必ず、どこか1箇所を書き忘れます。

// ✅ 状態は1つ。あとは計算
const [tasks, dispatch] = useReducer(tasksReducer, initialTasks);

const doneTasks = tasks.filter((t) => t.done);
const remaining = tasks.length - doneTasks.length;
const isEmpty = tasks.length === 0;

判断の手順は、これだけです。

  1. useState / useReducer を書く前に、「これ、他の状態から計算できないか?」と聞く
  2. 計算できるなら、ただの変数にする
  3. Context に入れる前に、「これ、本当に遠くまで届ける必要があるか?」と聞く

「状態管理が難しい」の半分は、そもそも状態が多すぎることが原因です。道具を足す前に、状態を減らしてください。


つまずいたところ

画面に「担当: 名無し」と出る → <UserContext.Provider> の内側にいません。 App.jsx で、Provider が <div className="app"> の外側を囲んでいるか確認してください。エラーは出ないので、この症状だけが手がかりです。

Cannot read properties of undefined (reading 'user') → createContext() を、既定値なしで呼んでいます。 useContext の結果が undefined になり、そこから { user } を取り出そうとして落ちています。createContext({ user: "名無し", setUser: () => {} }) のように、形の合った既定値を必ず入れてください。

Failed to resolve import "./contexts/UserContext.js"(TaskMeta.jsx で) → パスが違います。 TaskMeta.jsx は src/components/ にあるので、../contexts/UserContext.js です。.. を忘れています。

The requested module does not provide an export named 'default' → import UserContext from ... と書いています。 UserContext.js は名前付き export なので、import { UserContext } from ... と波かっこが要ります。

useMemo を足したのに、まだ全部再描画される → useMemo(() => { user, setUser }, [user]) になっていませんか。 { } が関数の本体だと解釈され、undefined が返っています。 () => ({ user, setUser }) と、丸かっこで囲んでください。

Console のログが、必ず2回ずつ出る → <StrictMode> です。異常ではありません。 開発中だけ、React がわざと2回呼んでいます。外さないでください。

「全部完了にする」を押しても何も起きない → action.type の綴りが、App.jsx と tasksReducer.js で食い違っています。 default で throw してあるので、Console に「知らない action.type です: …」と赤く出ているはずです。そこに打ち間違えた文字が出ています。

tasksReducer is not defined → import { tasksReducer, initialTasks } from "./tasksReducer.js"; を書き忘れています。App.jsx は src/ にあるので、./tasksReducer.js(components/ ではありません)です。

Board.jsx を children に変えたら、中身が消えた → {children} を書き忘れています。 <div className="board"></div> だけでは、渡されたものはどこにも出ません。

「使う人を切り替える」を押しても、ヘッダーだけ変わって各行が変わらない → TaskMeta がまだ props の user を見ています。 useContext(UserContext) に置き換わっているか確認してください。

ホストのブラウザから繋がらない → sudo ufw allow 5173/tcp の忘れか、--host 0.0.0.0 の付け忘れです。①に戻ってください。


後片づけ

開けたポートを閉じます。

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

~/react-demo/ は、この先でも使うので残してください。

最終的なファイル構成は、こうなっています。

bash
$ ls -R ~/react-demo/src
/home/user/react-demo/src:
App.css  App.jsx  assets  components  contexts  index.css  main.jsx  tasksReducer.js

/home/user/react-demo/src/components:
Board.jsx  Header.jsx  TaskForm.jsx  TaskItem.jsx  TaskList.jsx  TaskMeta.jsx  TaskSummary.jsx

/home/user/react-demo/src/contexts:
UserContext.js

全部やり直したいときは:

bash
$ rm -rf ~/react-demo

~/vite-demo/(Vanilla)と ~/web/(素のHTML)も、まだ消さないでください。


まとめ

  • バケツリレーは、階層が深いから起きるのではない。 組み立て方で起きる。 だからまず組み立て方で消す
  • children は特別な props。 囲むだけの部品は、これで props がゼロになる。 今回 Board は5個から1個(children だけ)になった
  • children で消せるのは「中身が固定で、囲むだけ」の階層まで。 map の中を通る props は消せない。 そこが Context の出番
  • Context は「配線を省く道具」。 途中を飛ばして、下のどこからでも読める
  • createContext の既定値が使われるのは、Provider の外で読んだときだけ。 書き忘れてもエラーが出ず、既定値が黙って表示される。 既定値は「おかしいと分かる値」にする
  • 1〜2段しか渡さないなら、props のほうがよい。 Context にすると「どこから来た値か」が見えなくなる
  • Context の値が変わると、読んでいる全員が再レンダリングされる。 memo を付けても止められない
  • value={{ a, b }} は、親が描き直されるたびに新しいオブジェクトになる。 中身が同じでも「変わった」と判断される。useMemo で固定する
  • () => ({ ... }) の丸かっこを忘れない。 () => { ... } は何も返さない関数になる
  • よく変わる値と、めったに変わらない値を、1つの Context に混ぜない。 分けるか、そもそも入れない
  • useReducer は「状態の入れ物」ではなく「変え方の一覧表」。 1つの状態を3〜4通り以上に変えるようになったら移す
  • reducer は React も DOM も知らない、ただの関数。 だから読みやすく、後でテストもしやすい
  • default で throw する。 打ち間違えが黙って無視されるのが、一番困る
  • useReducer はライブラリではない。 Redux の考え方が React 本体に入ったもの
  • 「状態管理」は1つの問題ではない。 画面の状態・フォームの状態・サーバーの状態(キャッシュ)・URL の状態は別物で、道具が違う
  • サーバーから来たデータの持ち主は、サーバー。 手元にあるのは写しで、古くなる。 これは状態ではなくキャッシュの問題
  • Redux と TanStack Query は競合しない。 解いている問題が違う。比較記事に並んでいても、選ぶものとは限らない
  • ライブラリを入れないのは、まだ困っていないから。 props → children → Context → ライブラリ。 順番を飛ばすと、どれが何を解いたのか分からなくなる
  • 道具を足す前に、状態を減らす。 「状態管理が難しい」の半分は、状態が多すぎることが原因

参考リンク


次に読む

この記事は 【第4段階】フロントエンド の 3 / 15 本目です。

記事
← 前の記事コンポーネントは見た目の部品ではない — propsと状態
→ 次の記事/tasks/3 を直接開くと404 — ルーティング

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

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

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

Frontend›State Management
  • Context API
  • useReducer
  • 状態の種類の切り分け

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

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

コメント

コメントする

目次