画面が重いのに、どこが何回描き直されているのか分かりません。Reactが再描画を決める仕組みを、押していない子まで動く例で確かめます。
これは深掘りです。本線の順路ではありません。 本線のコンポーネントの回で 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の仕業で、バグではないこと
この記事でやること
~/reactlabに練習用の React プロジェクトを1つ作る- 親・子・孫に
console.logを入れて、ボタンを押し、呼ばれた回数を実際に数える - React DevTools の「Highlight updates」と Profiler で、同じことを目で見る
- 同じ値を
setする / 同じ中身のオブジェクトをsetするを並べて、止まる場合と止まらない場合を作る - 子を止める3つの手を、①state を下げる → ②
childrenで渡す → ③React.memoの順に試す StrictModeを戻して、2回呼ばれることを確認し、練習場を片づける
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| レンダー(render) | コンポーネントの関数を呼んで、返り値(見た目の設計図)を作ること。 この時点では画面は変わっていない |
| コミット(commit) | レンダーの結果を実際の DOM に反映する段階。画面が変わるのはここだけ |
| 再描画(re-render) | 2回目以降のレンダー。 この記事では「関数がもう一度呼ばれること」の意味で使う |
Object.is | 2つの値が同じかを判定する JavaScript の関数。React が「変わったか」を決めるのに使っている |
| 参照(reference) | オブジェクトや配列の置き場所を指す値。中身ではなく置き場所で比べられる |
React.memo | props が前回と同じなら、再描画を飛ばすという指示を、コンポーネントに付ける関数 |
children | タグで囲んだ中身が、自動で渡ってくる特別な props |
StrictMode | 開発中だけ、わざと二重に呼んで危ない書き方をあぶり出す仕組み |
| Profiler | React DevTools に付いている、どのコンポーネントが何ミリ秒かかったかを記録するタブ |
① 練習場を作る
本線で作った ~/react-demo/ は触りません。 壊しながら試すので、別のプロジェクトを1つ作ります。
VMの中で実行します。
確認: ls src で App.jsx と main.jsx が出れば成功です。
App.css App.jsx assets index.css main.jsx
ポートを開けます。本線のViteの回で 5173 を閉じていたら、開け直しが要ります。
起動します。
--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を使ってもいません。 それでも、押すたびに全部呼ばれています。
表にします。
| props | count を使うか | 押すと呼ばれるか | |
|---|---|---|---|
App | — | 使う | 呼ばれる(当然) |
Child | 無し | 使わない | 呼ばれる |
Grandchild | 無し | 使わない | 呼ばれる |
これが「無駄な再描画」の正体です。
React は、「この子は props が変わっていないから飛ばそう」という判断を、何もしなければしません。 親の関数をもう一度呼べば、その中の <Child /> も当然もう一度評価され、Child の関数が呼ばれます。さらにその中の <Grandchild /> も同じです。
「props が変わったコンポーネントだけが再描画される」と思っていたら、それが誤解です。 React は、親から下を丸ごと呼び直します。 止めたければ、こちらから止めると言わなければいけません。
[スクリーンショット: 01_console3行.png] ボタンを3回押したあとの Console を撮ってください。App / Child / Grandchild の3行が、押した回数だけ揃って並んでいるのが読みどころです。
目で見る — Highlight updates
ログで数えられましたが、実際の画面で「どこが光るか」を見ると一発で分かります。
- F12 → Components タブを開く
- 右上の歯車アイコンを押す
- General の中の 「Highlight updates when components render」 にチェックを入れる
この状態でボタンを押すと、再描画されたところが、緑色の枠で一瞬光ります。
親のボタンを押しただけなのに、子の枠も孫の枠も光ります。 ログで見たことが、そのまま画面に出ます。
[スクリーンショット: 02_highlight_updates.png] 「Highlight updates」を有効にしてボタンを押した瞬間の画面を撮ってください。親だけでなく、子と孫の領域まで枠が付いているのが分かる形で。
時間を測る — Profiler
回数の次は、時間です。
- F12 → Profiler タブ
- 歯車 → 「Record why each component rendered while profiling」にチェック
- 左上の青い丸(記録開始)を押す
- ボタンを2〜3回押す
- もう一度丸を押して記録を止める
記録が表示されたら、コンポーネントの棒をクリックします。右側に、こんな行が出ます。
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.memo | memo + たいてい 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 で包む」は、遅くする方向に働くことがあります。 コードも読みにくくなります。
打つ手順は、いつもこれです。
- Profiler で記録する(どこが何ミリ秒かかっているか)
- 上位に出たものだけを見る(
console.logで回数も数える) - ①state を下げる → ②
childrenで渡すを先に試す - それでも残ったところにだけ
memoを貼る - もう一度 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/ とは別物です。消す前に、何を消すのかを目で見ます。
開発サーバーを止めます。 動かしている端末で Ctrl + C を押します。止まったことを確認します。
確認: 何も返らなければ、止まっています。
ポートを閉じます。
確認: 一覧に 5173/tcp が残っていなければ成功です。
プロジェクトを消します。
確認: 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 自身が理由を教えてくれる
参考リンク
- roadmap.sh — React
- React 公式 — Render and Commit
- React 公式 — State as a Snapshot
- React 公式 — memo
- React 公式 — StrictMode
- React 公式 — useCallback
- React 公式 — React Developer Tools
- MDN — Object.is
- Vite 公式ドキュメント
次に読む
この記事は 【深掘り】React の 3 / 24 本目です。
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- 再描画のきっかけは3つだけ
- children で渡す / React.memo は最後
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント