propsとstateの違い — pushしても画面が変わらない

propsとstateを使い分ける。propsとstateのカード、部品のブロックと更新マーク。

本線を書き終えたあと、しばらくは同じところで毎回止まっていました。 値を1つ足すたびに、「これは useState で持つのか、親から props で受け取るのか」を考え込む。決められないので、とりあえず子に useState で持たせる。しばらくして、別の場所から同じ値を見たくなって、全部書き直す。

前回: JSXの正体 — ただの関数呼び出しだった

これは深掘りです。本線の順路ではありません。 本線のコンポーネントの回で props と state を分け、リフトアップまで進んだ人が、「で、結局この値はどっちに置けばいいのか」が毎回決まらないところで手が止まったときに読む記事です。飛ばしても本線は進みます。

この記事のコマンドは、すべて VM の中(Ubuntu)で打ちます。 Windows の PowerShell ではありません。 画面の確認はホストの Windows のブラウザから行います。 本線で作った ~/react-demo/ は触りません。 この記事はわざと壊す手順を含むので、新しく ~/reactlab/ を作って、そこだけで実験します。

さらに悪いことに、書き換えたのに画面が変わらないという現象に何度も当たりました。push した。代入した。エラーは出ない。コンソールに出力すると値は確かに変わっている。それなのに画面だけ古い。

この2つは、別々の問題に見えて、どちらも「state とは何か」を誤解していたことが原因でした。分かってしまえば、判断は3つの問いに落ちます。

迷い答えを決める問い
どこに置くかその値を読むのは誰か。 1つのコンポーネントだけか、兄弟も見るか、アプリ全体か
変えていいのかそれは誰のものか。 自分の state なら変えられる。props は他人のもの
そもそも持つべきか他の値から計算で出せるか。 出せるなら持ってはいけない

この記事は、この3つを実際に動かして確かめます。 読むだけで納得しにいくと、また同じところで止まります。

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

目次

この記事でわかること

  • props と state は「置き場所の違い」ではなく「持ち主の違い」であること。誰のものかが決まれば、変えていいかも自動的に決まる
  • 兄弟どうしで値を共有したくなった瞬間、選択肢は「親に上げる」しかないこと。横に渡す道は存在しない
  • push や直接代入で画面が変わらないのは、React が「中身」ではなく「同じ入れ物かどうか」しか見ていないから。バグではなく仕様
  • setCount(count + 1) を2回書いても1しか増えないこと。count はその場で更新される変数ではなく、その回の描画に焼き付いた値であること
  • 合計や絞り込み結果を state に持つと、必ずどこかでズレること。それは「更新を忘れた」のではなく、持ったこと自体が間違い

この記事でやること

  1. ~/reactlab/ を新しく作る(本線の ~/react-demo/ は残したまま)
  2. 同じ機能を、state の位置を変えて2通り作る(子に持たせる版 → 親に上げる版)
  3. props.x = 1 を実際に書いて、何が起きるかをブラウザのコンソールで確かめる
  4. 配列を push して再描画されないところを見てから、新しい配列を作る書き方に直す
  5. setCount(count + 1) を2回書いて1しか増えないのを確かめ、関数型更新に直す
  6. 合計を state に持って、削除でズレるところを見てから、計算で出す形に直す

先に知る言葉

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

言葉意味
state(状態)そのコンポーネントが自分で持っていて、変えると画面が描き直される値。useState で作る
props親から子へ渡される値。子から見ると読むだけの引数で、書き換えてはいけない
再レンダリング(再描画)コンポーネントの関数がもう一度呼ばれて、新しい見た目が計算されること。画面が全部作り直されるわけではない
リフトアップ(lift state up)state を、それを使う全員の共通の親まで引き上げること
参照(reference)配列やオブジェクトを入れている変数が指している「入れ物そのもの」。中身が違っても、同じ入れ物なら「同じ」と判断される
Object.isJavaScript の等値判定の1つ。React が「前と変わったか」を判定するのに使う
不変(イミュータブル)元を書き換えず、新しいものを作って置き換えるやり方
スプレッド構文[...arr, x] や { ...obj, a: 1 } のように、中身を新しい入れ物に展開して写す書き方
関数型更新setCount(c => c + 1) のように、「いまの値を受け取って、次の値を返す関数」を渡す更新のしかた
派生状態(derived state)他の state から計算できるのに、わざわざ別の state として持ってしまった値

「state」を「変数」だと思っていると、この記事の内容は全部おかしく見えます。 state は変数ではありません。 React に預けてある値です。だから代入では変わりません(React が知らないため)。 そして useState が返す値は「いまの値」ではなく、「この回の描画のときの値」です。この2つが、後半の落とし穴の全部の正体です。


① 準備 — reactlab を作る

VM の中で、本線とは別のディレクトリを作ります。

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

対話で聞かれることがあります。 テンプレートを指定しているので、聞かれたらそのまま Enter で進みます。終わったら中に入って、依存を入れます。

bash
$ cd ~/reactlab
$ npm install

node_modules が作られるまで1〜2分かかります。 終わったら確認します。

bash
$ ls src
App.css  App.jsx  assets  index.css  main.jsx

この一覧が出れば準備完了です。 出ないときは、npm create の途中で止まっている可能性があります。rm -rf ~/reactlab で消して、もう一度やり直してください。

本線の ~/react-demo/ が無事なことも、ここで確認しておきます。

bash
$ ls ~/react-demo/src

これが表示されれば、本線側は無傷です。 以降、この記事では ~/reactlab/ の中しか触りません。

ポートを開けて起動する

VM のファイアウォールで 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
  VITE v7.1.5  ready in 412 ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: http://192.168.226.50:5173/

ホストの Windows のブラウザで、Network: に出ている URL を開きます(IPは自分の値に。分からなければ VM で ip a)。Vite の初期画面が出れば成功です。

[スクリーンショット: 01_reactlab起動.png] ホストのブラウザで http://192.168.x.x:5173/ を開き、Vite + React の初期画面が出ているところを撮ってください。

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

ブラウザのコンソールを開けておく

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

コンソールの読み方そのものが不安なら、先に本線の開発者ツールの回を読んでおくと楽になります。


② props と state は、何がどう違うのか

先に表で整理します。 ただし、この表は読んで納得するためのものではなく、後の節で「本当にそうなる」ことを確かめるための答え合わせ用です。

propsstate
誰のものか親のもの。子は預かっているだけそのコンポーネント自身のもの
どこで作られるか親が渡す(呼び出し側の JSX に書かれる)自分の中(useState で作る)
変えられるか変えてはいけない(読み取り専用)変えられる。ただし専用の関数(setXxx)でだけ
変えると何が起きるか何も起きない(React は気づかない)そのコンポーネントが再レンダリングされる
値が変わるきっかけ親が再レンダリングされて、違う値を渡してきたとき自分が setXxx を呼んだとき
消えるタイミング親が渡さなくなったときそのコンポーネントが画面から消えたとき

ここで一番大事なのは、右下から2番目の行です。

setXxx を呼ぶことは、「値を変えること」ではありません。 「値を変えたから、描き直してくれ」と React に伝えることです。

代入では画面が変わらないのは、これが理由です。 代入は JavaScript の世界の出来事で、React には何も伝わっていません。

もう1つ。「props は読み取り専用」は、React が意地悪をしているのではありません。

  • 子が props を書き換えても、親の持っている元の値は変わりません。 親が次に再レンダリングされた瞬間、子の書き換えは上書きされて消えます
  • つまり書き換えは「効いたり効かなかったり」する。これが一番たちの悪い壊れ方です

だから「変えるな」ではなく、「変えても意味がないので、変えようとするな」が正確な言い方です。


③ state を持たせる場所を、動かして決める

ここが本題です。 同じ機能を、state の位置だけ変えて2通り作ります。

作るものは単純にします。個数を増減するボタンと、その個数から金額を出す表示です。

版A — 子が自分で state を持つ

まず src/components/ を作ります。

bash
$ mkdir -p ~/reactlab/src/components

VS Code から VM を開いて編集します(やり方は本線のVS Code Remote の回にあります)。src/components/Stepper.jsx を新規作成します。

import { useState } from "react";

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

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

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

import Stepper from "./components/Stepper";

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

保存すると、ブラウザが自動で切り替わります。 +と−を押して、数が動くことを確認してください。

この時点では、版Aは完全に正しい設計です。 count を読むのは Stepper だけだからです。「とりあえず子に持たせる」が間違いなのではありません。 使うのが1人なら、それが正解です。

兄弟が出てきた瞬間に、詰む

ここで、要件を1つ足します。 「個数 × 単価 の金額を、別のところに出したい」。

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

export default function Price() {
  const unit = 250;

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>単価: {unit}円</p>
      <p>合計: ???円</p>
    </div>
  );
}

src/App.jsx に並べます。

import Stepper from "./components/Stepper";
import Price from "./components/Price";

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

保存して画面を見てください。 合計のところが ???円 のままです。

ここで手を止めて、「Price から count を取る方法」を、思いつくかぎり考えてみてください。 私は当時、次の3つを本気で試そうとしました。

思いついたことなぜ駄目か
Price の中で Stepper の count を読む読めません。 count は Stepper 関数の中のローカルな値で、外からは存在すら見えない
Price にも useState(0) を書く書けますが、別物になります。 Stepper の+を押しても Price の数は 0 のまま。2つの真実ができる
Stepper から Price に渡す渡せません。 Stepper は Price を呼んでいない。兄弟であって親子ではない

この3つが全部潰れることが、この記事で一番体験してほしいところです。

React では、データは親から子へしか流れません。 横(兄弟どうし)に渡す道は、そもそも用意されていません。 だから、2人が同じ値を見たくなった瞬間、その値は「2人の共通の親」に上げるしかないのです。 これは設計の好みではなく、選択肢が1つしかないという話です。

試しに、2番目(Price にも useState(0) を書く)を実際にやってみてください。 Price.jsx をこう書きます。

import { useState } from "react";

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

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>単価: {unit}円</p>
      <p>合計: {unit * count}円</p>
      <button onClick={() => setCount(count + 1)}>Price側の+</button>
    </div>
  );
}

上の+を3回、下の+を1回押してください。 個数は 3、合計は 250円 になります。エラーは出ません。警告も出ません。ただ、静かにずれているだけです。

[スクリーンショット: 02_二重state_ずれ.png] 個数が 3、合計が 250円 と食い違って表示されているところを撮ってください。

「同じ意味の値を2箇所に持つと、必ずずれる」は、この画面のことです。ずれた後に気づくので、原因の特定が遅れます。

版B — 親に上げる(リフトアップ)

直します。 count を、Stepper と Price の共通の親である App に移します。

src/components/Stepper.jsx を書き直します。useState が消えて、props を受け取るだけになります。

export default function Stepper({ count, onChange }) {
  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>個数: {count}</p>
      <button onClick={() => onChange(count - 1)}>−</button>
      <button onClick={() => onChange(count + 1)}>+</button>
    </div>
  );
}

src/components/Price.jsx も書き直します。こちらも useState が消えます。

export default function Price({ count }) {
  const unit = 250;

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>単価: {unit}円</p>
      <p>合計: {unit * count}円</p>
    </div>
  );
}

src/App.jsx が、state を持つ側になります。

import { useState } from "react";
import Stepper from "./components/Stepper";
import Price from "./components/Price";

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

  return (
    <div style={{ padding: "24px", fontFamily: "sans-serif" }}>
      <h1>reactlab</h1>
      <Stepper count={count} onChange={setCount} />
      <Price count={count} />
    </div>
  );
}

保存して、+を押してください。 個数と合計が同時に動きます。

[スクリーンショット: 03_リフトアップ後.png] +を3回押して、個数 3・合計 750円 が揃っているところを撮ってください。

2つの版を並べて、何が変わったか

版A(子が持つ)版B(親が持つ)
count の持ち主StepperApp
Stepper の役割数を持って、自分で変える受け取って表示し、変えたいことを親に知らせる
Price から見えるか見えない見える(親が渡してくれる)
真実は何個あるか2個(ずれる)1個
Stepper を単体で使えるか使える(<Stepper /> だけで動く)使えない(props を渡す親が要る)

最後の行が重要です。リフトアップは、良いことばかりではありません。

  • 子が自分で完結しなくなります。 使う側は必ず props を2つ渡さなければならない
  • 親が太ります。 state が増えていくと App が全部を抱えることになる
  • 途中の階層が、使いもしない props を通り抜けさせられます(バケツリレー)

だから「最初から全部親に上げておく」は間違いです。 共有したくなってから上げる。この順番が正しい。そのときにこの記事の版A→版Bの書き換えを1回やっておけば、迷いません。

なお、バケツリレーが本当に辛くなったときの話は、本線の状態管理の回にあります。 ここではまだ、リフトアップで足ります。


④ props は変更してはいけない — 実際に書いてみる

「読み取り専用」と言われても、書いたらどうなるのかを見ないと納得できません。 書きます。

src/components/Price.jsx を、一時的にこうします。

export default function Price(props) {
  const unit = 250;

  console.log("代入する前:", props.count);
  props.count = 999;
  console.log("代入した後:", props.count);

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>単価: {unit}円</p>
      <p>合計: {unit * props.count}円</p>
    </div>
  );
}

保存して、ブラウザのコンソールを見てください。 起きることは2通りのどちらかです。

(1)赤いエラーが出て、画面が真っ白になる

TypeError: Cannot assign to read only property 'count' of object '#<Object>'

これは React が開発中に props オブジェクトを凍結しているために起きます。凍結された(Object.freeze された)オブジェクトに、strict モードで代入すると、JavaScript が例外を投げます。

(2)エラーは出ず、コンソールに「代入した後: 999」と出て、合計も 249750円 になる

React の版によっては凍結されません。 その場合、代入は「成功」します。 ですが、成功しているのはこの1回の描画の間だけです。+を押して親が再レンダリングされると、親が渡してきた値で上書きされて、999 は消えます。

どちらが出ても、結論は同じです。

何が起きているか
エラーになる場合開発中に気づけるように、React がわざと止めている
エラーにならない場合もっと悪い。 動いているように見えて、親が描き直した瞬間に黙って消える
本番ビルド(npm run build)凍結は開発用の仕組みなので、本番では止めてくれません

props は「親のもの」です。 子は借りているだけなので、書き換えても親の持っている値は1ミリも変わりません。 親を変えたいなら、変えるのは親自身。 子ができるのは、親から渡された関数を呼んで「変えてほしい」と伝えることだけです。 版Bで onChange を渡したのは、まさにこれです。 データは下へ、知らせは上へ。

確認が済んだら、Price.jsx を版Bの形に戻してください。

export default function Price({ count }) {
  const unit = 250;

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>単価: {unit}円</p>
      <p>合計: {unit * count}円</p>
    </div>
  );
}

なぜ最初から { count } と分割代入で受け取るのが良いのかも、ここで分かります。props.count = ... と書けない形にしておけば、事故が起きようがないからです。


⑤ state は「置き換える」もので、「書き換える」ものではない

ここが、私が一番長く詰まったところです。

まず、動かないところを見る

src/components/TaskBox.jsx を作ります。わざと間違った書き方です。

import { useState } from "react";

export default function TaskBox() {
  const [tasks, setTasks] = useState(["牛乳を買う"]);
  const [text, setText] = useState("");

  const addWrong = () => {
    if (text === "") return;
    tasks.push(text);          // ← 元の配列を直接いじっている
    setTasks(tasks);           // ← 同じ配列を渡している
    console.log("いまの中身:", tasks);
  };

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <input value={text} onChange={(e) => setText(e.target.value)} />
      <button onClick={addWrong}>追加(壊れている版)</button>
      <ul>
        {tasks.map((t, i) => (
          <li key={i}>{t}</li>
        ))}
      </ul>
    </div>
  );
}

src/App.jsx に足します。

import { useState } from "react";
import Stepper from "./components/Stepper";
import Price from "./components/Price";
import TaskBox from "./components/TaskBox";

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

  return (
    <div style={{ padding: "24px", fontFamily: "sans-serif" }}>
      <h1>reactlab</h1>
      <Stepper count={count} onChange={setCount} />
      <Price count={count} />
      <TaskBox />
    </div>
  );
}

保存して、入力欄に「パンを買う」と打って、追加ボタンを押してください。

  • 画面のリストは「牛乳を買う」のまま、増えません
  • 入力欄は「パンを買う」のまま残ります(この版では、わざと setText("") を呼んでいません。呼ぶと text が変わって描き直しが起き、push 済みの配列がそのまま描かれてしまうためです。 試しに入力欄にもう1文字打つと、その描き直しで「パンを買う」が急に現れます)
  • コンソールには いまの中身: ['牛乳を買う', 'パンを買う'] と出ます

[スクリーンショット: 04_pushしても増えない.png] リストが1件のままなのに、コンソールには2件出ているところを、両方が写るように撮ってください。

これが「エラーも出ないのに画面だけ古い」の正体です。 データは確かに増えている。React が気づいていないだけです。

なぜ気づかないのか

React は、setTasks(...) に渡されたものが「前と違うか」を確認します。 そのときに使うのは、Object.is によるおおよそ === と同じ比較です。

そして、配列やオブジェクトの === は、中身を見ません。

この挙動は React のものではなく、JavaScript そのものの仕様です。 VM でそのまま試せます。

bash
$ node -e "const a=[1,2]; const b=a; b.push(3); console.log(a===b, a);"
true [ 1, 2, 3 ]

中身は変わったのに、a === b は true。 これがすべてです。

変数が持っているのは「中身」ではなく、「入れ物の場所」です。 push は入れ物の中身を増やしますが、入れ物そのものは同じです。 だから React から見ると、「前と同じものが渡ってきた。何も変わっていない。描き直す必要はない」になります。

なぜ React は中身まで比べないのか。 比べられないからではなく、比べると遅いからです。 1000件の配列を毎回全部比較していたら、画面を描き直すより比較のほうが重くなります。 だから React は「入れ物が違えば変わった、同じなら変わっていない」という、一瞬で終わる判定だけをします。

その代わり、私たちの側が「変えたら新しい入れ物にする」という約束を守る必要があります。 これが不変(イミュータブル)に扱うという言葉の中身です。

正しく直す

TaskBox.jsx を直します。追加・削除・書き換えの3つを、全部「新しい配列を作る」形にします。

import { useState } from "react";

export default function TaskBox() {
  const [tasks, setTasks] = useState(["牛乳を買う"]);
  const [text, setText] = useState("");

  const add = () => {
    if (text === "") return;
    setTasks([...tasks, text]);            // 新しい配列を作って置き換える
    setText("");
  };

  const remove = (index) => {
    setTasks(tasks.filter((_, i) => i !== index));   // 条件に合うものだけの新しい配列
  };

  const rename = (index) => {
    setTasks(tasks.map((t, i) => (i === index ? t + "(済)" : t)));  // 1件だけ差し替えた新しい配列
  };

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <input value={text} onChange={(e) => setText(e.target.value)} />
      <button onClick={add}>追加</button>
      <ul>
        {tasks.map((t, i) => (
          <li key={i}>
            {t}
            <button onClick={() => rename(i)}>済にする</button>
            <button onClick={() => remove(i)}>削除</button>
          </li>
        ))}
      </ul>
    </div>
  );
}

保存して、追加・済にする・削除を押してください。 今度は3つとも画面に出ます。

「元を変えるメソッド」と「新しく作るメソッド」

この区別さえ覚えれば、配列で迷わなくなります。

やりたいこと使ってはいけない(元を変える)使う(新しく作る)
末尾に足すarr.push(x)[...arr, x]
先頭に足すarr.unshift(x)[x, ...arr]
消すarr.splice(i, 1) / arr.pop()arr.filter((_, i) => i !== 対象)
1件だけ変えるarr[i] = xarr.map((v, i) => (i === 対象 ? x : v))
並べ替えるarr.sort() / arr.reverse()[...arr].sort() / [...arr].reverse()

sort の行に注意してください。 arr.sort() は戻り値も返すので、正しく動いているように見えます。 ですが元の配列も並べ替えてしまっています。 必ず [...arr] でコピーしてから並べ替えます。

オブジェクトも同じ

配列だけの話ではありません。 オブジェクトでも同じことが起きます。

const [user, setUser] = useState({ name: "太郎", age: 20 });

// 駄目
const wrong = () => {
  user.age = 21;
  setUser(user);        // 同じ入れ物 → 画面は変わらない
};

// 正しい
const right = () => {
  setUser({ ...user, age: 21 });   // 中身を写した新しい入れ物
};

{ ...user, age: 21 } は「user の中身を全部写して、age だけ上書きした新しいオブジェクト」という意味です。後ろに書いたほうが勝ちます。

入れ子になっている場合は、変える階層まで全部作り直す必要があります。

const [data, setData] = useState({ user: { name: "太郎", age: 20 }, memo: "" });

// 駄目(外側は新しくなるが、user は元の入れ物を書き換えている)
data.user.age = 21;
setData({ ...data });

// 正しい
setData({ ...data, user: { ...data.user, age: 21 } });

入れ子が3段以上になったら、それは「state の形が深すぎる」という合図です。 平らにできないか先に考えたほうが、たいてい早く終わります。


⑥ state の更新は、その場では起きない

もう1つ、実際に見ないと信じられない挙動があります。

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

import { useState } from "react";

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

  const plusTwoWrong = () => {
    setCount(count + 1);
    setCount(count + 1);
    console.log("この行での count:", count);
  };

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <p>count: {count}</p>
      <button onClick={plusTwoWrong}>+1を2回書いたボタン</button>
    </div>
  );
}

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

ボタンを押してください。 count は 2 ではなく 1 になります。 コンソールには この行での count: 0 と出ます。

[スクリーンショット: 05_2回書いても1しか増えない.png] ボタンを1回押して count が 1 になっている画面と、コンソールの出力を撮ってください。

なぜ 1 なのか

count は変数ではありません。 「この回の描画のときに、React が渡してくれた値」です。

ボタンを押した時点の描画では、count は 0 に固定されています。 関数の途中で setCount を呼んでも、この関数の中の count は最後まで 0 のままです。書いた2行は、実際にはこうです。

setCount(0 + 1);   // 次は 1 にして
setCount(0 + 1);   // 次は 1 にして(上書き)

結果、次の描画の count は 1。 React が2回目を無視したのではなく、こちらが2回とも「1にして」と言っているだけです。

ついでに、console.log が 0 を出す理由も同じです。 その関数が動いている間、count は絶対に変わりません。 「更新したはずなのに、直後に読むと古い」という現象は、全部これです。

関数型更新で直す

「いまの値を受け取って、次の値を返す関数」を渡すと、React はそれを順番に適用します。

const plusTwo = () => {
  setCount((c) => c + 1);
  setCount((c) => c + 1);
};

これは 2 増えます。 1つ目が 0 → 1、2つ目はその結果の 1 を受け取って 1 → 2 になるからです。

使い分けは1つだけ覚えれば足ります。

書き方使う場面
setCount(次の値)前の値と関係なく、値を決められるとき(setText("") など)
setCount(c => ...)前の値から計算するとき(増やす・減らす・配列に足す)

迷ったら関数型にしておいて損はありません。 前の値から計算しているのに setCount(count + 1) と書いている箇所は、いつか必ず1回ぶん取りこぼします。

配列でも同じです。

setTasks((prev) => [...prev, text]);

⑤で書いた setTasks([...tasks, text]) は、1回しか呼ばないなら正しく動きます。 ですが、まとめて2件足すような場面では、関数型でないと片方が消えます。


⑦ 「他から計算できる値」を state にしない

最後の落とし穴です。 これは動かなくなるのではなく、動いているように見えて、あるときだけ嘘をつく種類のバグです。

合計を state に持ってみる

src/components/Cart.jsx を作ります。わざと間違えます。

import { useState } from "react";

export default function Cart() {
  const [items, setItems] = useState([
    { name: "りんご", price: 120 },
    { name: "パン", price: 250 },
  ]);
  const [total, setTotal] = useState(370);   // ← 合計を state で持ってしまった

  const addApple = () => {
    setItems([...items, { name: "りんご", price: 120 }]);
    setTotal(total + 120);                   // 足すときは、ちゃんと直している
  };

  const removeLast = () => {
    setItems(items.slice(0, -1));            // 消すときに total を直し忘れた
  };

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <ul>
        {items.map((it, i) => (
          <li key={i}>
            {it.name} {it.price}円
          </li>
        ))}
      </ul>
      <p>合計: {total}円</p>
      <button onClick={addApple}>りんごを足す</button>
      <button onClick={removeLast}>最後の1件を消す</button>
    </div>
  );
}

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

「りんごを足す」を2回押してください。 合計は 610円。正しいです。 次に「最後の1件を消す」を2回押してください。 リストは2件に戻ったのに、合計は 610円のままです。

[スクリーンショット: 06_合計がずれる.png] リストが2件なのに合計が 610円 と表示されているところを撮ってください。

ここで「削除のほうにも setTotal を書き忘れただけだ」と考えると、同じ設計をずっと続けることになります。 書き忘れは症状であって、原因ではありません。

total は、items から必ず計算で出せる値です。 計算で出せる値を別に持つということは、同じ事実を2箇所に書くということです。 2箇所ある以上、いつか必ず片方だけ直し忘れます。 「気をつける」で防げるものではありません。

「更新の場所が2つなら気をつけられる」と思うかもしれません。 ですが、割引を足す・カートを空にする・別の画面から件数を変えると増えていき、そのうち1つを忘れます。 私は忘れました。

計算で出す形に直す

total の useState を丸ごと消します。 代わりに、描画のたびに計算します。

import { useState } from "react";

export default function Cart() {
  const [items, setItems] = useState([
    { name: "りんご", price: 120 },
    { name: "パン", price: 250 },
  ]);

  const total = items.reduce((sum, it) => sum + it.price, 0);   // 毎回ここで出す

  const addApple = () => {
    setItems((prev) => [...prev, { name: "りんご", price: 120 }]);
  };

  const removeLast = () => {
    setItems((prev) => prev.slice(0, -1));
  };

  return (
    <div style={{ border: "1px solid #ccc", padding: "12px", margin: "8px 0" }}>
      <ul>
        {items.map((it, i) => (
          <li key={i}>
            {it.name} {it.price}円
          </li>
        ))}
      </ul>
      <p>合計: {total}円</p>
      <button onClick={addApple}>りんごを足す</button>
      <button onClick={removeLast}>最後の1件を消す</button>
    </div>
  );
}

足しても消しても、合計が必ず合います。 「直し忘れる場所」が消えたからです。

注目してほしいのは、setTotal を書く場所が減ったのではなく、setTotal という関数自体が消えたことです。 バグの温床は、書き忘れではなく、存在していたことでした。

「毎回計算して遅くならないのか」

この疑問は正しいのですが、答えは「まず気にしなくていい」です。

  • reduce や filter は、数百件なら一瞬で終わります。 画面を描き直す処理のほうが、比べものにならないほど重い
  • 速さが問題になったときは、まず測ります。 開発者ツールの回でやったように、測らずに速くしようとすると、たいてい間違った場所を直します
  • 本当に重い計算だと分かってから、対策を考えれば間に合います。 先回りして state に持つのは、確実にズレるほうを選んでいるだけです

絞り込み結果も同じ

「完了だけ隠す」のような絞り込みも、結果を state に持ってはいけません。

持つもの種類
items(元のデータ)state。他から作れない
keyword(検索文字)state。ユーザーが打つもので、他から作れない
filtered(絞り込んだ結果)state にしない。items と keyword から計算できる
const [items, setItems] = useState([...]);
const [keyword, setKeyword] = useState("");

const filtered = items.filter((it) => it.name.includes(keyword));

keyword が変われば、filtered は次の描画で自動的に正しくなります。 同期させるコードは、1行も要りません。


⑧ state を置く場所の判断3条

ここまでを、実際に使える形にまとめます。 値を1つ足すたびに、上から順に3つ答えるだけです。

第0条(先に効く) — そもそも state にするか

「他の state から計算で出せるか」を最初に聞きます。

  • 出せるなら、state にしない。 描画のときに計算する(⑦)
  • 出せないなら、次へ

判定は「この値は、他の値が決まっても自由に動けるか」で付きます。 合計は動けません(items が決まれば決まる)。検索文字は動けます(ユーザーしか決められない)。

第1条 — そのコンポーネントだけが使うか

使うのが1つのコンポーネントだけなら、そこに useState で持ちます。

  • 入力欄の文字、開いている・閉じているの状態、ホバー中かどうか
  • 上げてはいけません。 上げると、親が知らなくていいことを知り、無関係な再レンダリングが増えます

第2条 — 兄弟が使うか

2つ以上のコンポーネントが同じ値を読むなら、共通の親に上げます(③のリフトアップ)。

  • 上げる先は「一番上」ではなく、「両方を含む一番近い親」です
  • 迷ったら、一度下に置いて、共有したくなってから上げます。 先回りで上げると、使いもしない props が階層を通り抜けます

第3条 — アプリ全体が使うか

ログイン中のユーザー、配色テーマ、言語のように、どの画面からも読むものは、上げ続けても解決しません。

  • props が5階層を通り抜けるようになったら、リフトアップの限界のサインです
  • ここから先は別の道具の話で、本線の状態管理の回で扱っています

表にすると

問い答え置き場所
他から計算できる?できる持たない(計算する)
読むのは自分だけ?はいそのコンポーネントの useState
兄弟も読む?はい共通の親(リフトアップ)
どの画面からも読む?はいリフトアップの外の仕組み(別の回)

上から順に当てはめて、最初に「はい」になったところが答えです。 この順番を守るのが大事で、下から考えると、いきなり大げさな仕組みを選んでしまいます。


つまずいたところ

push してから setTasks([...tasks]) と書いて、直ったと思っていました。 確かに画面は更新されます。新しい入れ物になるからです。 ですが、元の配列はすでに書き換わっています。 別の場所が同じ配列を見ていると、そちらは知らないうちに中身が変わっている。 「動いたから正しい」で先に進むと、後で原因の分からないズレとして返ってきました。 push を書かない、が正解でした。

console.log の値を信じて、1時間溶かしました。 setCount の直後に console.log(count) を書いて、古い値が出るのを見て「更新に失敗している」と判断しました。失敗していません。 その関数の中の count は、最後まで変わらないというだけでした。確かめたいなら、関数の中ではなく、コンポーネントの本体(return の手前)に console.log を置きます。 そこは描画のたびに動くので、新しい値が出ます。

リフトアップを覚えた直後、全部の state を App に上げました。 「上げれば共有できる」が気持ちよかったので、入力欄の文字まで App に持たせました。結果、文字を1つ打つたびにアプリ全体が再レンダリングされて、目に見えて重くなりました。 リフトアップは「必要になったらやる」もので、予防としてやるものではありません。

props を書き換えてもエラーが出ず、しばらく気づきませんでした。 ④で書いたとおり、環境によっては素通りします。 本番ビルドでは止めてくれません。 function F(props) ではなく function F({ count }) と分割代入で受け取るようにしてからは、そもそも書けなくなったので、事故が消えました。気をつけるのではなく、書けない形にする。

「合計を state に持つのは駄目」と読んで納得したのに、次の日に同じことをしました。 「件数」だったので、別物だと思ったのです。同じです。 判定は名前ではなく、「他の値から出せるか」だけです。⑦のズレる画面を自分で作ってからは、間違えなくなりました。読んで納得したものは忘れます。


後片づけ

この記事で使った ~/reactlab/ は、実験用です。 消して構いません。

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

bash
$ cd ~
$ rm -rf ~/reactlab

開けたポートを閉じます。 本線の続きをすぐやる予定なら、開けたままで構いません。

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

本線のものが残っていることを、必ず確認してください。

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

この一覧が出れば、本線側は無傷です。 ~/react-demo/ は、この先の本線でも使うので消さないでください。

もし ~/reactlab/ を残して続きをやりたい場合は、node_modules だけで数百MBあります。容量が気になるなら、中身は残して依存だけ消せます。

bash
$ rm -rf ~/reactlab/node_modules

戻すときは cd ~/reactlab && npm install で復元できます。 package.json が残っていれば、node_modules はいつでも作り直せます(本線のnpmの回で書いたとおりです)。


まとめ

  • props と state の違いは、置き場所ではなく持ち主。 props は親のもの、state は自分のもの。持ち主が決まれば、変えていいかも決まる
  • setXxx は「値を変える」命令ではなく、「変えたから描き直してくれ」という連絡。代入では連絡が行かないので、画面は変わらない
  • 兄弟どうしで値を渡す道は存在しない。 見たいのが2人になった瞬間、共通の親に上げる以外の選択肢がない
  • リフトアップは「共有したくなってから」やる。 先回りで上げると、親が太り、使わない props が階層を通り抜け、無関係な再レンダリングが増える
  • 上げる先は「一番上」ではなく「両方を含む一番近い親」
  • props.x = 1 は、エラーになるか、黙って消えるかのどちらか。 開発中は React が凍結して止めてくれることがあるが、本番ビルドでは止まらない
  • function F({ count }) と分割代入で受け取れば、書き換えようがなくなる。 気をつけるのではなく、書けない形にする
  • push で画面が変わらないのはバグではない。 React は「中身」ではなく「同じ入れ物か」しか見ていない(Object.is の比較)
  • 中身を全部比べないのは、比べると描き直すより重くなるから。 その代わりこちらが「変えたら新しい入れ物にする」を守る
  • 元を変えるメソッドを使わない。 push → [...arr, x]、splice → filter、arr[i] = → map、sort → [...arr].sort()
  • sort は戻り値も返すので、正しく動いて見えるのに元も並べ替えている。 必ずコピーしてから
  • オブジェクトも同じ。 { ...obj, key: 値 }。入れ子は、変える階層まで全部作り直す。3段以上になったら形を疑う
  • setCount(count + 1) を2回書いても1しか増えない。 count はその回の描画に焼き付いた値で、関数の途中では絶対に変わらない
  • 前の値から計算するなら関数型更新 setCount(c => c + 1)。 迷ったら関数型にしておく
  • setXxx の直後の console.log は必ず古い値を出す。 失敗しているのではない。 新しい値を見たいなら、return の手前に置く
  • 合計・件数・絞り込み結果を state に持たない。 他から計算できる値を持つのは、同じ事実を2箇所に書くことで、必ず片方を直し忘れる
  • 直し忘れは症状で、原因ではない。 消すべきは書き忘れではなく、その state そのもの
  • 毎回計算して遅くなる心配は、まず要らない。 測ってから考える。先回りは、確実にズレるほうを選んでいる
  • 判断は上から3条。 ① 計算で出せるか → 出せるなら持たない ② 自分だけが読むか → その場に置く ③ 兄弟も読むか → 共通の親へ。それでも足りなければ別の仕組み

参考リンク


次に読む

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

記事
← 前の記事JSXの正体 — ただの関数呼び出しだった
→ 次の記事再描画の仕組み — 押していない子まで描き直される

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

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

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

Frontend›React — Props & State
  • stateを置く場所とリフトアップ
  • stateは置き換える / 派生値をstateにしない

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

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

コメント

コメントする

目次