再描画の仕組み — 押していない子まで描き直される

Reactの再描画。押していない子まで、なぜ? 更新マークが付いた画面カードとノートパソコン。

画面が重いのに、どこが何回描き直されているのか分かりません。Reactが再描画を決める仕組みを、押していない子まで動く例で確かめます。

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

これは深掘りです。本線の順路ではありません。 本線のコンポーネントの回で props と state の関係が分かった人が、「画面が重い。でも、どこが何回動いているのか分からない」ところで止まったときに読む記事です。飛ばしても本線は進みます。

この記事のコマンドは、すべて VM の中(Ubuntu Server)で打ちます。 画面の確認はホストの Windows のブラウザです。 npm が入っていることが前提です(npmの回)。

React で画面を作っていると、必ずこの相談が出てきます。

「Reactが遅いんですけど、どうすればいいですか」

そして、検索すると React.memo と useCallback と useMemo が並んだ記事が出てきます。自分も、意味が分からないまま memo で包みました。 速くなったのかどうかも分かりませんでした。

遅い原因は、たいてい「無駄な再描画」です。 ここまでは合っています。問題は、その次です。

どこが、何回、無駄に呼ばれているのかを、誰も数えていない。

数えずに memo を貼るのは、熱があるかどうかを測らずに薬を飲むのと同じです。効いたかどうかも分かりません。パフォーマンス改善の回で「速くする前に必ず測る」と書きました。フロントエンドでも、順番は同じです。

この記事は、まず数えるところから始めます。道具は console.log です。

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

目次

この記事でわかること

  • 親が再描画されると、子も孫も全部再描画されること。props が1つも変わっていなくても呼ばれる
  • 再描画のきっかけは3つしかないこと(state が変わった / 親が再描画された / Context が変わった)。props が変わったから、は入っていない
  • 「再描画」は「DOMを書き換える」ことではないこと。関数をもう一度呼んで、前回との差だけを DOM に反映するという2段構えであること
  • 同じ値を set しても再描画されないこと(Object.is で比べている)。だが、オブジェクトは中身が同じでも毎回「別物」になること
  • 子を止める手は3つあり、効く順番があること。React.memo は最後で、props にオブジェクトや関数を渡すと効かないこと
  • children として渡すと、親が再描画されても子は作り直されないこと。一番効くのに、一番知られていない
  • 開発中だけコンポーネントが2回呼ばれるのは StrictMode の仕業で、バグではないこと

この記事でやること

  1. ~/reactlab に練習用の React プロジェクトを1つ作る
  2. 親・子・孫に console.log を入れて、ボタンを押し、呼ばれた回数を実際に数える
  3. React DevTools の「Highlight updates」と Profiler で、同じことを目で見る
  4. 同じ値を set する / 同じ中身のオブジェクトを set するを並べて、止まる場合と止まらない場合を作る
  5. 子を止める3つの手を、①state を下げる → ②children で渡す → ③React.memo の順に試す
  6. StrictMode を戻して、2回呼ばれることを確認し、練習場を片づける

先に知る言葉

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

言葉意味
レンダー(render)コンポーネントの関数を呼んで、返り値(見た目の設計図)を作ること。 この時点では画面は変わっていない
コミット(commit)レンダーの結果を実際の DOM に反映する段階。画面が変わるのはここだけ
再描画(re-render)2回目以降のレンダー。 この記事では「関数がもう一度呼ばれること」の意味で使う
Object.is2つの値が同じかを判定する JavaScript の関数。React が「変わったか」を決めるのに使っている
参照(reference)オブジェクトや配列の置き場所を指す値。中身ではなく置き場所で比べられる
React.memoprops が前回と同じなら、再描画を飛ばすという指示を、コンポーネントに付ける関数
childrenタグで囲んだ中身が、自動で渡ってくる特別な props
StrictMode開発中だけ、わざと二重に呼んで危ない書き方をあぶり出す仕組み
ProfilerReact DevTools に付いている、どのコンポーネントが何ミリ秒かかったかを記録するタブ

① 練習場を作る

本線で作った ~/react-demo/ は触りません。 壊しながら試すので、別のプロジェクトを1つ作ります。

VMの中で実行します。

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

確認: ls src で App.jsx と main.jsx が出れば成功です。

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

ポートを開けます。本線のViteの回で 5173 を閉じていたら、開け直しが要ります。

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

起動します。

bash
$ npm run dev -- --host 0.0.0.0

--host 0.0.0.0 が要る理由は、これが無いと VM の中からしか繋がらないからです(ネットワークの回)。VM の IP は ip a で調べます。

ホストの Windows のブラウザで http://<VMのIP>:5173/ を開いて、Vite のロゴが出れば準備完了です。

この記事では、以降ずっと npm run dev を動かしたままにします。 ファイルを保存するたびに、ブラウザが自動で更新されます。 止めるのは Ctrl + C、再開は同じコマンドです。

React DevTools を入れる

ブラウザの F12(開発者ツール)に、React 用のタブを足します。 開発者ツールの回で開いたあの画面に、「Components」と「Profiler」の2つが増えます。

  • Chrome / Edge: 拡張機能ストアで React Developer Tools を入れる
  • Firefox: アドオンで同じ名前のものを入れる

入れるのは、ホストの Windows のブラウザです。 VM の中ではありません。画面を見ているのはホスト側だからです。

入ったら F12 を開いて、上のタブに Components と Profiler が増えていることを確認してください。増えていなければ、ページを再読み込みします。

② 再描画の回数を、実際に数える

ここがこの記事の芯です。 議論する前に数えます。

親・子・孫を作る

src/Grandchild.jsx を新しく作ります。

let calls = 0

export default function Grandchild() {
  calls += 1
  console.log('Grandchild が呼ばれた:', calls, '回目')
  return <p>孫です</p>
}

let calls = 0 を関数の外に置いているのがポイントです。 関数の中に書くと、呼ばれるたびに 0 に戻ってしまいます。外に置くと、ページを読み込んでからの累計になります。

src/Child.jsx を作ります。

import Grandchild from './Grandchild'

let calls = 0

export default function Child() {
  calls += 1
  console.log('Child が呼ばれた:', calls, '回目')
  return (
    <div style={{ border: '1px solid #999', padding: '8px' }}>
      <p>子です</p>
      <Grandchild />
    </div>
  )
}

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

import { useState } from 'react'
import Child from './Child'

let calls = 0

export default function App() {
  calls += 1
  console.log('App が呼ばれた:', calls, '回目')

  const [count, setCount] = useState(0)

  return (
    <div style={{ padding: '16px' }}>
      <h1>再描画を数える</h1>
      <button onClick={() => setCount(count + 1)}>
        親のカウント: {count}
      </button>
      <Child />
    </div>
  )
}

ここまでで確認してください。 ブラウザに「再描画を数える」という見出しと、ボタンと、枠に囲まれた「子です」「孫です」が出ていれば成功です。

最初に、ログが2回ずつ出ることに気付く

F12 の Console タブを開いて、ページを再読み込みします。

App が呼ばれた: 1 回目
Child が呼ばれた: 1 回目
Grandchild が呼ばれた: 1 回目
App が呼ばれた: 2 回目
Child が呼ばれた: 2 回目
Grandchild が呼ばれた: 2 回目

1回も押していないのに、2回ずつ出ています。

これはバグではありません。 StrictMode という開発中だけの仕組みが、わざと2回呼んでいます。 理由は ⑦ でちゃんと説明します。

いまは数えたいので、一時的に外します。 src/main.jsx を開きます。

import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './index.css'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(
  <StrictMode>
    <App />
  </StrictMode>,
)

<StrictMode> の2行を外します。

import { createRoot } from 'react-dom/client'
import './index.css'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(
  <App />,
)

⑦ で必ず戻します。 消したままにしないでください。

再読み込みすると、1回ずつになります。

App が呼ばれた: 1 回目
Child が呼ばれた: 1 回目
Grandchild が呼ばれた: 1 回目

これで、数えられる状態になりました。

ボタンを押して、数える

Console を開いたまま、ボタンを3回押します。

App が呼ばれた: 2 回目
Child が呼ばれた: 2 回目
Grandchild が呼ばれた: 2 回目
App が呼ばれた: 3 回目
Child が呼ばれた: 3 回目
Grandchild が呼ばれた: 3 回目
App が呼ばれた: 4 回目
Child が呼ばれた: 4 回目
Grandchild が呼ばれた: 4 回目

ここが、この記事で一番大事なところです。

Child にも Grandchild にも、props を1つも渡していません。 count を使ってもいません。 それでも、押すたびに全部呼ばれています。

表にします。

propscount を使うか押すと呼ばれるか
App—使う呼ばれる(当然)
Child無し使わない呼ばれる
Grandchild無し使わない呼ばれる

これが「無駄な再描画」の正体です。

React は、「この子は props が変わっていないから飛ばそう」という判断を、何もしなければしません。 親の関数をもう一度呼べば、その中の <Child /> も当然もう一度評価され、Child の関数が呼ばれます。さらにその中の <Grandchild /> も同じです。

「props が変わったコンポーネントだけが再描画される」と思っていたら、それが誤解です。 React は、親から下を丸ごと呼び直します。 止めたければ、こちらから止めると言わなければいけません。

[スクリーンショット: 01_console3行.png] ボタンを3回押したあとの Console を撮ってください。App / Child / Grandchild の3行が、押した回数だけ揃って並んでいるのが読みどころです。

目で見る — Highlight updates

ログで数えられましたが、実際の画面で「どこが光るか」を見ると一発で分かります。

  1. F12 → Components タブを開く
  2. 右上の歯車アイコンを押す
  3. General の中の 「Highlight updates when components render」 にチェックを入れる

この状態でボタンを押すと、再描画されたところが、緑色の枠で一瞬光ります。

親のボタンを押しただけなのに、子の枠も孫の枠も光ります。 ログで見たことが、そのまま画面に出ます。

[スクリーンショット: 02_highlight_updates.png] 「Highlight updates」を有効にしてボタンを押した瞬間の画面を撮ってください。親だけでなく、子と孫の領域まで枠が付いているのが分かる形で。

時間を測る — Profiler

回数の次は、時間です。

  1. F12 → Profiler タブ
  2. 歯車 → 「Record why each component rendered while profiling」にチェック
  3. 左上の青い丸(記録開始)を押す
  4. ボタンを2〜3回押す
  5. もう一度丸を押して記録を止める

記録が表示されたら、コンポーネントの棒をクリックします。右側に、こんな行が出ます。

Why did this render?
  The parent component rendered.

The parent component rendered. — 「親が再描画されたから」。 これが、この記事の答えそのものです。 推測ではなく、React 自身がそう言っています。

[スクリーンショット: 03_profiler_理由.png] Profiler で Child を選び、右側に Why did this render? と The parent component rendered. が出ている画面を撮ってください。

③ 再描画のきっかけは、3つしかない

数えたので、整理できます。 コンポーネントの関数がもう一度呼ばれるきっかけは、これで全部です。

きっかけ何が起きたか止められるか
① state が変わったそのコンポーネントの中で setSomething が呼ばれ、値が前と違った止められない(それが目的)
② 親が再描画されたprops が変わっていなくても呼ばれる止められる(⑥でやる)
③ Context が変わったuseContext で受け取っている値が変わった止めにくい(読む場所を減らす)

「props が変わったから」は入っていません。 props が変わるのは、②が起きた結果であって、きっかけではありません。ここを逆に覚えていると、memo を貼る場所を間違えます。

③ の Context については、本線の状態管理の回で作った形がそのまま当てはまります。Context の値が変われば、その値を読んでいるコンポーネントは、親が再描画されていなくても再描画されます。 この記事では ① と ② に集中します。

④ 「再描画」は「DOMを書き換える」ことではない

ここで、多くの人が過剰に怖がります。

「え、押すたびに画面全体が作り直されているんですか?」

違います。 React の更新は2段構えです。

段階やること重さ
① レンダーコンポーネントの関数を呼んで、返り値(設計図)を作る軽い。ただの関数呼び出し
② コミット前回の設計図と比べて、変わった部分だけを本物の DOM に書き込む重い。画面が動くのはここ

console.log が出ているのは、①だけです。 ボタンを押したとき、Grandchild の関数は呼ばれていますが、返した内容が前回と同じなので、DOM には1文字も書かれていません。

確かめられます。 F12 の Elements タブで <p>孫です</p> の行を開いておいて、ボタンを押してください。その行はハイライトされません。 変わっているのはボタンの中の数字だけです。

だから「再描画されている=遅い」ではありません。 軽い関数が100回呼ばれても、体感では何も起きません。 問題になるのは、その関数の中で重い計算をしているか、呼ばれるコンポーネントが数千個あるときだけです。

この「差分だけ DOM に反映する」仕組みが、仮想DOM と呼ばれているものです。 中身と、それを使わないフレームワーク(Svelte / Solid)との違いは、フレームワークを並べた回で実際に3つ作って比べました。この記事では、そちらには踏み込みません。 ここでやるのは測定です。

⑤ 同じ値を set しても、再描画されない

「state が変わったら再描画される」と書きました。 その「変わった」の判定を見ます。

同じ数字を入れてみる

src/App.jsx のボタンの下に、もう1つボタンを足します。

      <button onClick={() => setCount(count + 1)}>
        親のカウント: {count}
      </button>

      <button onClick={() => setCount(0)}>
        0 を入れ直す
      </button>

まず「親のカウント」を押して 0 以外にしてから、「0 を入れ直す」を押します。1回目は 0 に戻り、ログが出ます。

そのあと、もう一度「0 を入れ直す」を押してください。

(何も出ない)

何回押しても、ログが増えません。 すでに 0 なので、React が「変わっていない」と判断して、再描画を打ち切っています。

細かい話を1つだけ。 同じ値を set したとき、React がその1回だけもう一度レンダーしてから止まることがあります。押し続けてもログが増え続けないことが確認できれば、狙いどおりです。

何と比べているのか

React が使っているのは Object.is です。 ブラウザの Console に直接打って確かめられます。

Object.is(0, 0)
Object.is('a', 'a')
Object.is({ name: 'taro' }, { name: 'taro' })
Object.is([1, 2], [1, 2])
true
true
false
false

下の2つが false です。

中身は同じに見えます。 ですが、オブジェクトと配列は「中身」ではなく「置き場所」で比べられます。 { name: 'taro' } と書くたびに、新しい置き場所が確保されます。 見た目が同じでも、React から見ればまったく別のものです。

オブジェクトだと止まらないことを実演する

App.jsx に、オブジェクトの state を足します。

  const [count, setCount] = useState(0)
  const [user, setUser] = useState({ name: 'taro' })

ボタンも足します。

      <button onClick={() => setUser({ name: 'taro' })}>
        同じ内容のオブジェクトを入れる: {user.name}
      </button>

押してください。 画面の文字は taro のまま、1文字も変わりません。

App が呼ばれた: 8 回目
Child が呼ばれた: 8 回目
Grandchild が呼ばれた: 8 回目

押すたびに、全部呼ばれ続けます。

set するもの中身Object.is再描画
setCount(0)(すでに 0)同じtrue止まる
setUser({ name: 'taro' })(同じ内容)同じに見えるfalse止まらない

これが、React で「何もしていないのに再描画され続ける」ときの、最も多い原因です。 サーバーから取ってきたデータを、内容が同じでも毎回 setState している。 それだけで、画面全体が回り続けます。

逆に言うと、ここには落とし穴の裏面もあります。

user.name = 'jiro'
setUser(user)

これは動きません。 中身を書き換えてから同じオブジェクトを渡しているので、Object.is が true になり、React は「変わっていない」と判断します。 画面は taro のままです。

必ず新しいオブジェクトを作って渡します。

setUser({ ...user, name: 'jiro' })

本線のコンポーネントの回で「同じ意味のデータを2箇所に持たない」と書きました。 ここはその隣の話で、「持っているデータを、直接書き換えない」です。理由が Object.is だと分かると、覚えることではなくなります。

⑥ 子を再描画させない、3つの手

ここからが本題です。 ②で見た「親が再描画されると子も全部」を、止めていきます。

順番があります。 検索するといきなり React.memo が出てきますが、それは3番目です。

重い子を1つ作る

止める効果が見えるように、わざと重いコンポーネントを作ります。 src/Heavy.jsx を作ります。

let calls = 0

export default function Heavy() {
  calls += 1
  console.log('Heavy が呼ばれた:', calls, '回目')

  const start = performance.now()
  let sum = 0
  for (let i = 0; i < 20000000; i += 1) {
    sum += i
  }
  const ms = Math.round(performance.now() - start)

  return <p>重い計算: {ms} ミリ秒かかりました</p>
}

2000万回の足し算をしているだけです。意味のある処理ではありません。呼ばれると、体感で分かるくらい止まるのが目的です。

App.jsx の <Child /> の下に置きます。

      <Child />
      <Heavy />

import Heavy from './Heavy' を上に足すのを忘れないでください。

ボタンを押してみてください。 押すたびに画面が一瞬固まります。 数字を1つ増やしているだけなのに、です。

これが「Reactが遅い」の正体です。 遅いのは React ではありません。押していないコンポーネントの中の重い処理が、毎回呼ばれているだけです。

手① — state を下げる

一番最初に考えるのはこれです。

いま count は App にあります。 ですが、count を使っているのはボタン1つだけです。画面全体の親が持っている必要はありません。

src/Counter.jsx を作って、ボタンと state を、そこにまとめて閉じ込めます。

import { useState } from 'react'

let calls = 0

export default function Counter() {
  calls += 1
  console.log('Counter が呼ばれた:', calls, '回目')

  const [count, setCount] = useState(0)

  return (
    <button onClick={() => setCount(count + 1)}>
      カウント: {count}
    </button>
  )
}

App.jsx から count の state とボタンを消し、<Counter /> を置きます。

import Child from './Child'
import Heavy from './Heavy'
import Counter from './Counter'

let calls = 0

export default function App() {
  calls += 1
  console.log('App が呼ばれた:', calls, '回目')

  return (
    <div style={{ padding: '16px' }}>
      <h1>再描画を数える</h1>
      <Counter />
      <Child />
      <Heavy />
    </div>
  )
}

押してください。

Counter が呼ばれた: 2 回目
Counter が呼ばれた: 3 回目
Counter が呼ばれた: 4 回目

Counter しか出ません。 App も Child も Heavy も、1回も呼ばれていません。 固まりもしません。

何が起きたか。 state が変わったのは Counter の中です。再描画されるのは、その state を持っているコンポーネントから下だけです。Counter の下には何もありません。

「state を、それを使うところまで下げる」。 これが一番強い手です。 ライブラリも、memo も、何も要りません。構造を直しただけです。

本線のリフトアップと逆向きの操作です。 2つの子が同じデータを見るなら上げる、1つしか使っていないなら下げる。 判断の基準は同じで、「そのデータを本当に必要としているのは誰か」です。

手② — children として渡す

手①は「state を下げられるとき」にしか使えません。

下げられない場合を作ります。 Counter が持っている count を、周りの見た目にも使いたいとします。たとえば「押した回数によって枠の色が変わる」といった場合です。

こうなると、state は上に戻さざるを得ません。ですが、その場合でも Heavy を止められます。

src/Frame.jsx を作ります。

import { useState } from 'react'

let calls = 0

export default function Frame({ children }) {
  calls += 1
  console.log('Frame が呼ばれた:', calls, '回目')

  const [count, setCount] = useState(0)

  return (
    <div style={{ border: `4px solid hsl(${count * 40} 70% 50%)`, padding: '12px' }}>
      <button onClick={() => setCount(count + 1)}>枠の色を変える: {count}</button>
      {children}
    </div>
  )
}

Frame は state を持ち、押すと自分の見た目(枠の色)が変わります。 そして、中身は children として受け取っているだけです。

App.jsx で、Heavy を Frame で囲みます。

      <Frame>
        <Heavy />
      </Frame>

押してください。

Frame が呼ばれた: 2 回目
Frame が呼ばれた: 3 回目

枠の色は変わるのに、Heavy は呼ばれません。固まりません。

なぜ止まるのか。 ここが理解の山です。

<Heavy /> という設計図を作っているのは、Frame ではなく App です。 App は再描画されていないので、その設計図は前回とまったく同じものです。 Frame が再描画されて {children} を返しても、React は「これは前と同じ設計図だ」と分かるので、中に降りていきません。

⑤ でやった Object.is が、ここでも効いています。children に入っているのは、App が1回だけ作ったオブジェクトで、押しても作り直されていません。

書き方<Heavy /> を作るのは誰か親が再描画されたとき
Frame の中に直接書くFrame毎回作り直される → 呼ばれる
children で渡すApp(外側)同じものが渡る → 呼ばれない

この手は、一番効くのに一番知られていません。 memo も useCallback も要りません。 JSX の書き方を変えただけです。 「state を持つコンポーネントを、できるだけ内側の、小さい部品にする」という考え方の、もう1つの形です。

[スクリーンショット: 04_childrenで止まる.png] Frame のボタンを何回か押したあとの Console を撮ってください。Frame の行だけが並んでいて、Heavy の行が増えていないのが読みどころです。

手③ — React.memo

①も②も使えないときに、初めてこれを使います。「props が前回と同じなら、飛ばしてくれ」と明示する関数です。

効果が見えるように、Heavy を Frame の中に直接置き直します。

import { useState } from 'react'
import Heavy from './Heavy'

export default function Frame() {
  const [count, setCount] = useState(0)
  return (
    <div style={{ padding: '12px' }}>
      <button onClick={() => setCount(count + 1)}>カウント: {count}</button>
      <Heavy />
    </div>
  )
}

この状態だと、押すたびに Heavy が呼ばれて固まります。 確認してから進んでください。

src/Heavy.jsx を memo で包みます。

import { memo } from 'react'

let calls = 0

function Heavy() {
  calls += 1
  console.log('Heavy が呼ばれた:', calls, '回目')

  const start = performance.now()
  let sum = 0
  for (let i = 0; i < 20000000; i += 1) {
    sum += i
  }
  const ms = Math.round(performance.now() - start)

  return <p>重い計算: {ms} ミリ秒かかりました</p>
}

export default memo(Heavy)

押してください。 Heavy のログが増えなくなります。props を1つも渡していないので、「前回と同じ」だからです。

memo が効かなくなるのを、その場で見る

ここが、memo を貼った人がハマるところです。

Frame.jsx で、Heavy にインラインでオブジェクトを渡します。

      <Heavy style={{ color: 'crimson' }} />

押してください。

Heavy が呼ばれた: 2 回目
Heavy が呼ばれた: 3 回目

memo を貼ったままなのに、また呼ばれています。 固まります。

理由は ⑤ と完全に同じです。 { color: 'crimson' } は、Frame が再描画されるたびに新しく作られます。 中身は同じでも Object.is は false です。memo は「props が変わった」と判断して、素通しします。

関数でも同じことが起きます。

      <Heavy onDone={() => console.log('done')} />

アロー関数も、書くたびに新しい関数オブジェクトです。 これも memo を無効にします。

渡すもの毎回別物になるかmemo
数値・文字列・真偽値ならない効く
インラインのオブジェクト {...}なる効かない
インラインの配列 [...]なる効かない
インラインの関数 () => {}なる効かない

memo を貼ったのに速くならない、の原因はほぼこれです。 貼った本人は「memo が効いていない」と思いますが、memo は正しく働いています。 「props が変わった」という判定が、本当にそうなっているだけです。

これを直すために useMemo(オブジェクトを使い回す)と useCallback(関数を使い回す)があります。 ただし、それらを足すたびに、コードは読みにくくなります。

だから順番が大事です。

順手追加するコード効き方
①state を下げる無し(構造を直すだけ)一番強い
②children で渡す無し(書き方を変えるだけ)強い。範囲が広い
③React.memomemo + たいてい useMemo / useCallback効くが、条件付きで、読みにくくなる

①と②を試さずに③から入ると、useCallback だらけの読めないコードになったうえに、速くならないという結果になります。

[スクリーンショット: 05_memoが効かない.png] <Heavy style={{ color: 'crimson' }} /> にした状態でボタンを押し、memo を貼っているのに Heavy のログが増えている Console を撮ってください。

⑦ StrictMode で2回呼ばれる

②で外したものを、戻します。 src/main.jsx を元に戻してください。

import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './index.css'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(
  <StrictMode>
    <App />
  </StrictMode>,
)

再読み込みして、ボタンを押します。

Frame が呼ばれた: 2 回目
Frame が呼ばれた: 3 回目

押した回数の2倍、ログが出ます。

これはバグではありません。 そして、直す必要もありません。

開発中(npm run dev)本番(npm run build 後)
StrictMode有効。わざと2回呼ぶ何もしない。1回だけ

なぜわざと2回呼ぶのか。

コンポーネントの関数は、「何回呼んでも同じ結果になる」ように書かなければいけません。 呼ぶたびに外の変数を書き換えたり、配列に追加したりしていると、表示が呼ばれた回数に依存します。 StrictMode は、それをわざと2回呼んで、その場でおかしくすることで見つけてくれます。

この記事の let calls = 0 と calls += 1 が、まさに「やってはいけない書き方」の見本です。 レンダーのたびに外の変数を書き換えています。だから2回呼ばれると数字がずれます。

数を数えるためにわざとやりました。 本物のコードには書かないでください。

確認の型を1つだけ。

  • ログがきっちり2倍なら → StrictMode。正常
  • 2倍ではない、押していないのに増え続けるなら → 本当の無駄な再描画。⑤と⑥に戻る

[スクリーンショット: 06_strictmode2回.png] StrictMode を戻したあと、ボタンを1回押してログが2行出ている Console を撮ってください。

⑧ 測らずに memo を貼らない

最後に、この記事の結論と逆のことを書きます。

memo は、無料ではありません。

memo を付けると、React は再描画のたびに「前回の props と今回の props を全部比べる」という作業をします。

コンポーネント中身memo を付けると
重い計算をする2000万回の足し算明確に速くなる
<p>{text}</p> だけほぼ何もしない比較のコストのほうが高くなりうる

「とりあえず全部 memo で包む」は、遅くする方向に働くことがあります。 コードも読みにくくなります。

打つ手順は、いつもこれです。

  1. Profiler で記録する(どこが何ミリ秒かかっているか)
  2. 上位に出たものだけを見る(console.log で回数も数える)
  3. ①state を下げる → ②children で渡すを先に試す
  4. それでも残ったところにだけ memo を貼る
  5. もう一度 Profiler で測って、実際に減ったことを確かめる

5 を飛ばさないでください。 パフォーマンス改善の回で、SQL に索引を張ったあと EXPLAIN で確かめたのと同じです。貼っただけでは、効いたかどうか誰も知りません。

つまずいたところ

最初、console.log を関数の中に書いていました。

export default function Child() {
  let calls = 0
  calls += 1
  console.log('Child:', calls)
}

ずっと 1 としか出ませんでした。 「1回しか呼ばれていないのか」と思って、しばらく別の場所を疑っていました。let を関数の中に書けば、呼ばれるたびに初期化されるのは当たり前です。 変数のスコープの話で、React はまったく関係ありませんでした。

その次は StrictMode です。 数字が 2, 4, 6 と飛ぶのを見て、「1回押すと2回 state が更新されている」と思い込みました。 onClick を疑って、書き方を変えて、それでも2倍のままでした。開発中だけの仕組みだと知らなかったので、丸1回分の作業を無駄にしました。「押した回数のちょうど2倍か」を先に確かめれば、5秒で分かる話でした。

memo は、最初に貼った日から半年ほど「効かない道具」だと思っていました。 貼っても Profiler の数字が変わらない。理由が style={{ ... }} を渡していたからだと気付いたのは、この記事を書くために Object.is を Console で打ってからです。 Object.is({}, {}) が false と返ったのを見た瞬間に、過去の全部が繋がりました。動かない理由を、道具のせいにしていました。

children で止まる話は、ずっと知りませんでした。 検索して出てくる記事の見出しが、たいてい「React の再レンダリングを防ぐ3つの方法」で、memo / useMemo / useCallback の3つだからです。構造を直す手が、その3つに入っていません。 実際には、children に移し替えただけで消える無駄な再描画が、かなりの割合を占めていました。

Profiler の Why did this render? は、設定を入れないと出ません。 「そんな欄は無い」と思って使っていませんでした。歯車の中の Record why each component rendered while profiling にチェックを入れるだけでした。道具は、既定値のままだと本気を出しません。

後片づけ

~/reactlab は練習用に作ったものなので、丸ごと消して構いません。 本線で使った ~/react-demo/ とは別物です。消す前に、何を消すのかを目で見ます。

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

開発サーバーを止めます。 動かしている端末で Ctrl + C を押します。止まったことを確認します。

bash
$ ss -tlnp | grep 5173

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

ポートを閉じます。

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

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

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

bash
$ rm -rf ~/reactlab
$ ls ~

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

ブラウザ側の設定も戻します。

  • F12 → Components → 歯車 → 「Highlight updates when components render」のチェックを外す

外さないと、これから作るどの画面でも枠が光り続けます。 便利なので付けたままにしても構いませんが、付けていることを覚えておいてください。

戻し方: もう一度試したくなったら、①の npm create vite@latest reactlab -- --template react からやるだけです。数分で戻せます(node_modulesは消してよい)。 React Developer Tools の拡張は、消さないでください。 これからずっと使います。

まとめ

  • 「Reactが遅い」の原因は、たいてい無駄な再描画。 だが、直す前にまず数える。 道具は console.log と Profiler
  • 親が再描画されると、子も孫も全部再描画される。 props を1つも渡していなくても呼ばれる
  • 再描画のきっかけは3つだけ。 ① state が変わった / ② 親が再描画された / ③ Context が変わった。「props が変わったから」は入っていない
  • 「再描画」は「DOMを書き換える」ことではない。 ① 関数を呼んで設計図を作る(軽い)→ ② 差分だけ DOM に反映する(重い)の2段構え
  • だから「再描画されている=遅い」ではない。 問題になるのは、その中で重い処理をしているか、数が多すぎるとき
  • 同じ値を set しても再描画されない。 React は Object.is で比べている
  • Object.is({a:1}, {a:1}) は false。 オブジェクトと配列は中身ではなく置き場所で比べられる。同じ内容でも毎回別物
  • だから、state のオブジェクトを直接書き換えて set しても画面は変わらない。 { ...user, name: 'jiro' } のように新しく作って渡す
  • 子を止める手は3つあり、順番がある。 ①state を下げる → ②children で渡す → ③React.memo
  • ①が一番強い。 state を、それを使うところまで下げれば、上のコンポーネントは呼ばれなくなる。追加コードは無し
  • ②が一番知られていない。 children で渡すと、その設計図を作っているのは外側の親なので、中の親が再描画されても作り直されない
  • ③は条件付き。 props にインラインのオブジェクト・配列・関数を渡すと、memo は素通しする。memo が壊れているのではなく、本当に props が変わっている
  • 開発中にコンポーネントが2回呼ばれるのは StrictMode。 バグではなく、本番では1回。 「ちょうど2倍か」を先に確かめる
  • 測らずに memo を貼らない。 中身が軽いコンポーネントでは、比較のコストのほうが高くなりうる
  • Profiler の Why did this render? は、歯車の設定を入れて初めて出る。 出れば The parent component rendered. と、React 自身が理由を教えてくれる

参考リンク


次に読む

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

記事
← 前の記事propsとstateの違い — pushしても画面が変わらない
→ 次の記事useStateとuseReducer — 読み込み中なのにエラーもある

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

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

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

Frontend›React — Rendering
  • 再描画のきっかけは3つだけ
  • children で渡す / React.memo は最後

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

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

コメント

コメントする

目次