useMemoとuseCallbackは、付けるほど速くなるものではありません。効く条件と、かえって遅くなる場合を測って確かめます。
これは深掘りです。本線の順路ではありません。 本線のコンポーネントとpropsの回まで終わった人が、「useMemo と useCallback を、いつ付ければいいのか分からない」ところで止まったときに読む記事です。飛ばしても本線は進みます。
この記事のコマンドは、すべて VM の中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。 画面の確認は、ホストの Windows のブラウザで行います。 本線で作った
~/react-demo/には触りません。 この記事では、まっさらな~/reactlab/を新しく作ります。
人のコードを読んでいて、こういうものを見たことがあります。
const name = useMemo(() => user.firstName + ' ' + user.lastName, [user])
const isAdult = useMemo(() => age >= 18, [age])
const label = useMemo(() => `${count} 件`, [count])
全部の変数が useMemo で包まれています。 書いた本人に聞くと、こう返ってきました。
「付けておけば速くなると思って」
これは、速くなりません。 それどころか、この3行は、包む前より確実に遅くなっています。
理由は単純です。useMemo は計算を消す道具ではなく、計算を「前回の結果と交換する」道具だからです。交換するには、前回の依存配列と今回の依存配列を比べる必要があり、結果を持っておくためのメモリも要ります。
age >= 18の計算コストより、「前回の age と今回の age を比べて、保存してある結果を取り出す」コストのほうが高い。
つまり useMemo は、元の計算が、比較と保存のコストより明確に重いときにだけ得をします。 そしてほとんどの計算は、そこまで重くありません。
前回の記事で、「測らずに memo を貼らない」と書きました。この記事は、その続きです。 今回は React.memo そのものではなく、memo を効かせるための道具である useMemo と useCallback に絞ります。
そして、この記事の結論は最初に書きます。
useMemoとuseCallbackは、既定では書きません。 測って、遅くて、原因がこれだと分かったときにだけ足します。
対象レベル: 中級〜上級 / 区分: 発展
この記事でわかること
useMemoは計算を消していないこと。「前回の結果と交換する」だけなので、比較と保存のコストが必ず上乗せされる- 軽い計算に
useMemoを付けると、実測で遅くなること。速くなるのは、計算そのものが16ミリ秒以上あるときだけ useCallbackは「速くする道具」ではなく「関数の同一性を保つ道具」であること。渡す先がReact.memoでなければ、完全に無意味(そのうえ遅い)useCallbackにはもう1つ用途があること。useEffectの依存配列に関数を入れるとき- 依存配列にオブジェクトや配列を直接入れると、毎回「別物」になって全部が無意味になること。書いた本人からは、動いているように見える
- 直し方は3つしかないこと(プリミティブに分解する / コンポーネントの外に出す /
useMemoで作る) - React Compiler が自動でやるようになってきていること(2025年10月に安定版 1.0)。ただし、この記事では前提にしない
この記事でやること
~/reactlab/を新しく作り、ポート 5176 で起動するperformance.now()で「実際に何ミリ秒かかっているか」を先に測る- 20万件のソートに
useMemoを付けた前後を実測し、次に軽い計算に付けて逆に遅くなることを実測する React.memoした子に関数を渡し、useCallbackの有無でログの回数が変わるところを見る- 依存配列にオブジェクトを入れて、メモ化が全部無効になるところを再現し、3通りの直し方で直す
先に知る言葉
この記事に初めて出てくる言葉です。 詳しくは用語集にもあります。
| 言葉 | この記事での意味 |
|---|---|
| メモ化(memoization) | 一度計算した結果を取っておいて、同じ入力ならその結果を返すこと。計算が消えるのではなく、保存と比較に置き換わる |
useMemo | 値をメモ化するフック。useMemo(() => 計算, [依存]) |
useCallback | 関数そのものをメモ化するフック。useCallback(fn, [依存]) は useMemo(() => fn, [依存]) と同じ意味 |
React.memo | コンポーネントを包み、props が前回と同じなら再描画を飛ばす関数(前回でやりました) |
| 依存配列(dependency array) | フックの第2引数の [ ]。この中身が前回と違ったときだけ、中の処理をやり直す |
| 同一性(identity) | 「中身が同じか」ではなく「同じ物か」。 オブジェクトと関数は、中身が同じでも、作り直せば別物になる |
| プリミティブ | 数値・文字列・真偽値・null など、中身が同じなら同じ物として扱われる値 |
performance.now() | ブラウザが持っている、ミリ秒単位の時計。2回呼んで引き算すると、その間の時間が出る |
| React Compiler | メモ化を、人が書かずにビルド時に自動で入れるための仕組み。2025年10月に安定版(1.0)が出た |
① 準備 — reactlab を新しく作る
本線で作った ~/react-demo/ は、そのまま残します。 この記事はまっさらなプロジェクトでやります。わざと遅いコードを書くからです。
VMの中で、ホームディレクトリに戻って作ります。
質問が出たら、そのまま Enter で構いません。 版によっては「このまま npm install して起動しますか?」と聞かれます。そこは No(n)を選んでください。 ポートを自分で決めたいからです。
eslint.config.js index.html package.json public README.md src vite.config.js
この一覧が出れば成功です。 npm install は初回だけ数分かかります。何が起きているかはnpmの回、dist/ が何なのかはビルドツールの回にあります。
すでに
~/reactlab/がある場合(この深掘りシリーズの別の回で作っている場合)は、作り直さずにそのまま使って構いません。 その場合npm create viteは飛ばして、cd ~/reactlab && npm installだけ実行してください。
ポートを開ける
本線で 5173番を使っています。 ぶつからないように、この記事は 5176番でやります。
Status: active
To Action From
-- ------ ----
22/tcp ALLOW Anywhere
5173/tcp ALLOW Anywhere
5176/tcp ALLOW Anywhere
5176/tcp の行が出れば準備完了です。開けずに起動すると、ターミナルには「起動しました」と出るのに、ブラウザは読み込み中のままになります。「ポートが開いていない」ことは、ブラウザ側からは「サーバーが無い」ようにしか見えません。
起動する
ホストの Windows のブラウザで http://192.168.226.50:5176/ を開いてください(IPは自分の値に。分からなければ VM の中で ip a)。Vite のロゴとカウンターが出れば成功です。
止め方: ターミナルで Ctrl+C。この記事の間は起動したままで構いません。 保存するたびにブラウザが自動で更新されます。
[スクリーンショット: 01_reactlab起動.png] ホストのブラウザで :5176 を開き、Vite + React の初期画面が出ているところを撮ってください。アドレスバーのポート番号が 5176 になっているのが見える形で。
開発者ツールを開いておく
この記事は、ほぼすべて Console の数字を読む作業です。 ブラウザで F12 を押して、Console タブを開いたままにしてください。開発者ツール自体の使い方は開発者ツールの回にあります。
Vite の雛形は src/main.jsx で <StrictMode> を使っているので、開発中はコンポーネントが描画のたびに2回ずつ呼ばれます。 ログも2回ずつ出て、「〇回目」の数字は2ずつ進みます。この記事の出力例は1回ずつの形で書いているので、行数や数字が2倍の速さで進んでも正常です(<StrictMode> を外すと出力例のとおりになります)。
② 先に測る — 遅いかどうかを、確認してから始める
前回の記事で決めた型を、そのまま引き継ぎます。
数えてから直す。測ってから足す。
useMemo を足す前に、「その計算が、実際に何ミリ秒かかっているのか」を知らなければ、足す理由がありません。
道具は2つです。performance.now() と React DevTools の Profiler です。
performance.now() の使い方
ブラウザが持っている、ミリ秒単位の時計です。 2回呼んで引き算するだけです。
const start = performance.now()
// 測りたい処理
const ms = performance.now() - start
console.log('かかった時間:', ms.toFixed(2), 'ms')
Date.now() でも似たことはできますが、Date.now() はミリ秒単位までしか出ません。 1ミリ秒未満の処理を測ると、全部 0 になります。 performance.now() は小数まで返すので、こういう用途はこちらを使います。
Profiler の使い方
回数と、コンポーネント単位の時間を見るときはこちらです。React DevTools を入れていない場合は、前回の記事に入れ方があります。
- F12 → Profiler タブ
- 左上の青い丸(記録開始)を押す
- 画面を何回か操作する
- もう一度丸を押して記録を止める
棒が長いコンポーネントが、遅いコンポーネントです。そこ以外は、この記事の対象ではありません。
「なんとなく重い気がする」で
useMemoを足すのを、この記事では禁止にします。 足す前に、必ずミリ秒の数字を1つ持ってください。
③ useMemo が効く条件は、思っているより狭い
まず「効く場合」を作ります。 効く場合を1回も見ずに「使うな」と言われても、納得できないからです。
本当に重い計算を作る
src/heavy.js を新規作成します。
ファイルの中身は VS Code で書きます(VS Code から VM を直接編集する回)。
src/heavy.js(新規)
// 大量のデータを作る
export function makeItems(n) {
const items = []
for (let i = 0; i < n; i += 1) {
items.push({
id: i,
name: 'item-' + ((i * 7919) % n),
score: (i * 2654435761) % 100000,
})
}
return items
}
// それを絞り込んで、並べ替える
export function topByScore(items, min) {
return items
.filter((it) => it.score >= min)
.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
.slice(0, 20)
}
sort の中で localeCompare を呼んでいるのがポイントです。 数値の比較だけなら一瞬で終わりますが、文字列を辞書順で比べる処理は、比較1回あたりのコストが高いからです。
まず 1万件で測る — そして、差が出ない
src/components/SortDemo.jsx(新規)
import { useState } from 'react'
import { makeItems, topByScore } from '../heavy'
const ITEMS = makeItems(10000)
export default function SortDemo() {
const [min, setMin] = useState(50000)
const [count, setCount] = useState(0)
const start = performance.now()
const top = topByScore(ITEMS, min)
const ms = performance.now() - start
console.log('ソートにかかった時間:', ms.toFixed(2), 'ms')
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<p>件数: {ITEMS.length} / しきい値: {min}</p>
<button onClick={() => setCount(count + 1)}>
関係ないカウント: {count}
</button>
<button onClick={() => setMin(min === 50000 ? 60000 : 50000)}>
しきい値を変える
</button>
<ul>
{top.slice(0, 3).map((it) => (
<li key={it.id}>{it.name} — {it.score}</li>
))}
</ul>
</div>
)
}
src/App.jsx を、これだけにします。
import SortDemo from './components/SortDemo'
export default function App() {
return <SortDemo />
}
ブラウザで「関係ないカウント」ボタンを何回か押してください。 Console にこう出ます。
ソートにかかった時間: 2.40 ms
ソートにかかった時間: 2.10 ms
ソートにかかった時間: 2.30 ms
2ミリ秒。 これは、
useMemoを足す理由になりません。
人間が「引っかかった」と感じ始めるのは、おおよそ 16ミリ秒(1フレーム分)を超えたあたりからです。2ミリ秒は、体感できません。
ここで「1万件のソートは重い」という思い込みが1つ消えます。 計算量の回でやったとおり、ソートは n log n です。1万件なら、いまの CPU にとっては軽い部類です。
20万件にして、初めて「重い」が出る
SortDemo.jsx の1行を変えます。
const ITEMS = makeItems(200000)
もう一度、「関係ないカウント」を押してください。
ソートにかかった時間: 62.80 ms
ソートにかかった時間: 58.10 ms
ソートにかかった時間: 61.40 ms
約60ミリ秒。 押すたびに、画面が一瞬固まります。 これは、足す理由になります。
数字は環境で変わります。 自分の VM ではこうでしたが、大事なのは絶対値ではなく「体感できる遅さが出たか」です。
[スクリーンショット: 02_計測_ソート.png] 20万件にした状態でボタンを数回押し、Console に ソートにかかった時間: 60 ms 前後の行が並んでいるところを撮ってください。
useMemo を付ける
ここで初めて足します。
import { useMemo, useState } from 'react'
import { makeItems, topByScore } from '../heavy'
const ITEMS = makeItems(200000)
export default function SortDemo() {
const [min, setMin] = useState(50000)
const [count, setCount] = useState(0)
const top = useMemo(() => {
const start = performance.now()
const result = topByScore(ITEMS, min)
const ms = performance.now() - start
console.log('★ ソートを実行した:', ms.toFixed(2), 'ms')
return result
}, [ITEMS, min])
console.log('SortDemo が再描画された')
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<p>件数: {ITEMS.length} / しきい値: {min}</p>
<button onClick={() => setCount(count + 1)}>
関係ないカウント: {count}
</button>
<button onClick={() => setMin(min === 50000 ? 60000 : 50000)}>
しきい値を変える
</button>
<ul>
{top.slice(0, 3).map((it) => (
<li key={it.id}>{it.name} — {it.score}</li>
))}
</ul>
</div>
)
}
「関係ないカウント」を5回押してください。
SortDemo が再描画された
SortDemo が再描画された
SortDemo が再描画された
SortDemo が再描画された
SortDemo が再描画された
★ ソートを実行したが、1回も出ません。
再描画は5回起きています。 それでもソートは走っていません。 min も ITEMS も変わっていないので、前回の結果をそのまま返しているからです。画面の固まりも消えます。
「しきい値を変える」を押すと、今度は出ます。
★ ソートを実行した: 61.90 ms
SortDemo が再描画された
依存配列に入れた min が変わったので、計算し直しました。 これが useMemo の全部です。
useMemoは計算を速くしていません。 「やらなくていい回」を飛ばしているだけです。 必要な回は、依然として 60ミリ秒かかります。
軽い計算に付けると、逆に遅くなる — これも実測する
ここが本題です。 今度は、冒頭のコードと同じことを、200個ぶんやってみます。
src/components/LightDemo.jsx(新規)
import { useMemo, useState } from 'react'
const ROWS = Array.from({ length: 200 }, (_, i) => ({
id: i,
price: 100 + i,
}))
function PlainRow({ price }) {
const withTax = Math.round(price * 1.1)
return <span>{withTax} </span>
}
function MemoRow({ price }) {
const withTax = useMemo(() => Math.round(price * 1.1), [price])
return <span>{withTax} </span>
}
export default function LightDemo() {
const [useMemoVersion, setUseMemoVersion] = useState(false)
const [count, setCount] = useState(0)
const Row = useMemoVersion ? MemoRow : PlainRow
const rows = ROWS.map((r) => <Row key={r.id} price={r.price} />)
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<button onClick={() => setCount(count + 1)}>再描画する: {count}</button>
<button onClick={() => setUseMemoVersion(!useMemoVersion)}>
いまは {useMemoVersion ? 'useMemo あり' : 'useMemo なし'} / 切り替える
</button>
<p style={{ fontSize: '12px' }}>{rows}</p>
</div>
)
}
App.jsx を差し替えます。
import LightDemo from './components/LightDemo'
export default function App() {
return <LightDemo />
}
「再描画する」を何度か押し、切り替えて見比べてください。 画面も体感も変わりません。
ここで
performance.now()をROWS.map(...)に巻いても、useMemoのコストは測れません。mapが作っているのは React の要素オブジェクトだけで、PlainRow/MemoRowの中身(useMemoが動く場所)は、この行を抜けたあと React が描画する段階で実行されるからです。挟んだ時間には出てきません。
代わりに、useMemo が内部でやっていることを、素の JS で直接測ります。 500万回まわして差を出します。bench.mjs を作って node bench.mjs を実行してください。
// bench.mjs
const N = 5_000_000, price = 980
let sink = 0
// A: そのまま計算するだけ
let s = performance.now()
for (let i = 0; i < N; i++) sink += Math.round(price * 1.1)
console.log('計算だけ :', (performance.now() - s).toFixed(1), 'ms')
// B: useMemo が内部でやっていることを真似る(関数生成+依存配列+比較)
let prevDeps = null, prevVal = 0
s = performance.now()
for (let i = 0; i < N; i++) {
const compute = () => Math.round(price * 1.1) // 毎回アロー関数を作る
const deps = [price] // 毎回配列を作る
if (prevDeps && Object.is(prevDeps[0], deps[0])) sink += prevVal // 同じ → 再利用
else { prevVal = compute(); prevDeps = deps; sink += prevVal }
}
console.log('useMemo 相当:', (performance.now() - s).toFixed(1), 'ms')
計算だけ : 10.8 ms
useMemo 相当: 80.5 ms
useMemo相当のほうが、7〜8倍遅い。 数字は環境で変わりますが、必ず B(useMemo 相当)が重い——「関数を作り、配列を作り、前回と比べる」ぶん、Math.round(price * 1.1)そのものより高くつくからです。速くするつもりが、方向は逆になります。
理由は3つあります。
| 上乗せされるもの | 中身 |
|---|---|
| 関数の生成 | () => Math.round(price * 1.1) というアロー関数を、毎回1つ作っている。計算より高い |
| 依存配列の生成と比較 | [price] という配列を毎回作り、前回の配列と1つずつ Object.is で比べている |
| 保存領域 | React はコンポーネントごとに、フックの結果を並べて持っている。useMemo 1個ごとに枠が増える |
Math.round(price * 1.1) は、この3つを合計したものより軽いです。 だから負けます。
これが、冒頭の
const isAdult = useMemo(() => age >= 18, [age])の正体です。age >= 18は、CPU にとって1命令です。それを「保存して、比較して、取り出す」に置き換えれば、遅くなるのは当たり前でした。
判断基準
測った数字だけで決めます。
| その計算の実測値 | どうするか |
|---|---|
| 1ミリ秒未満 | 絶対に付けない。 付けると遅くなる |
| 1〜16ミリ秒 | 付けない。 体感できない。先に構造を直す(前回の「state を下げる」「children で渡す」) |
| 16ミリ秒以上、かつ毎回走っている | 付けてよい。 付けたあと、もう一度測る |
「16ミリ秒」は、目安であって法律ではありません。 大事なのは、「その数字を、自分で測って言えるかどうか」です。
④ useCallback の本当の用途は「関数の同一性」
ここが、いちばん誤解されているところです。
useCallbackは、関数の実行を速くしません。 関数を、毎回作り直さないようにするだけです。
そして、「関数が毎回作り直されると困る場所」は、実はほとんどありません。 困るのは、次の2つだけです。
用途1 — React.memo した子に渡すとき
前回、memo を貼った子にインラインの関数を渡すと memo が効かなくなることを見ました。 ここでは、その直し方をやります。
src/components/HeavyChild.jsx(新規)
import { memo } from 'react'
let calls = 0
function HeavyChild({ onPick }) {
calls += 1
console.log('HeavyChild が呼ばれた:', calls, '回目')
return <button onClick={() => onPick('A')}>子のボタン</button>
}
export default memo(HeavyChild)
src/components/CallbackDemo.jsx(新規)
import { useState } from 'react'
import HeavyChild from './HeavyChild'
export default function CallbackDemo() {
const [count, setCount] = useState(0)
const handlePick = (value) => {
console.log('選ばれた:', value)
}
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<button onClick={() => setCount(count + 1)}>親のカウント: {count}</button>
<HeavyChild onPick={handlePick} />
</div>
)
}
App.jsx を差し替えます。
import CallbackDemo from './components/CallbackDemo'
export default function App() {
return <CallbackDemo />
}
「親のカウント」を3回押してください。
HeavyChild が呼ばれた: 2 回目
HeavyChild が呼ばれた: 3 回目
HeavyChild が呼ばれた: 4 回目
memoで包んであるのに、押すたびに呼ばれています。
handlePick は、CallbackDemo が再描画されるたびに新しく作られています。 中身の文字は1文字も違いませんが、Object.is(前回の関数, 今回の関数) は false です。memo から見れば「props が変わった」ので、素通しします。
Console で確かめられます。
const f = () => 1
const g = () => 1
Object.is(f, g)
false
中身が同じでも、別物です。 JavaScript の基本の回で "1" == 1 をやりましたが、あれと同じ層の話です。「同じに見えるもの」と「同じもの」は別です。
[スクリーンショット: 03_useCallbackなしのログ.png] useCallback を付けない状態で親のボタンを3回押し、memo を貼っているのに HeavyChild が呼ばれた が増えている Console を撮ってください。
useCallback で包む
CallbackDemo.jsx の関数を包みます。
import { useCallback, useState } from 'react'
import HeavyChild from './HeavyChild'
export default function CallbackDemo() {
const [count, setCount] = useState(0)
const handlePick = useCallback((value) => {
console.log('選ばれた:', value)
}, [])
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<button onClick={() => setCount(count + 1)}>親のカウント: {count}</button>
<HeavyChild onPick={handlePick} />
</div>
)
}
依存配列が [](空)なのは、この関数が外の値を1つも使っていないからです。
もう一度、親のボタンを3回押してください。
何も出ません。
HeavyChildは、1回も呼ばれていません。
これが useCallback の効果です。 関数が「前回と同じ物」になったので、memo が「props は変わっていない」と判断できるようになりました。
順番を、間違えないでください。
useCallbackが仕事をしたのではありません。React.memoが仕事をしました。useCallbackは、memoが仕事をできる条件を整えただけです。
React.memo していない子に渡すなら、useCallback は完全に無意味
ここが、この章でいちばん言いたいところです。
src/components/PlainChild.jsx(新規)
let calls = 0
export default function PlainChild({ onPick }) {
calls += 1
console.log('PlainChild が呼ばれた:', calls, '回目')
return <button onClick={() => onPick('B')}>memo していない子</button>
}
CallbackDemo.jsx に足します。
import { useCallback, useState } from 'react'
import HeavyChild from './HeavyChild'
import PlainChild from './PlainChild'
export default function CallbackDemo() {
const [count, setCount] = useState(0)
const handlePick = useCallback((value) => {
console.log('選ばれた:', value)
}, [])
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<button onClick={() => setCount(count + 1)}>親のカウント: {count}</button>
<HeavyChild onPick={handlePick} />
<PlainChild onPick={handlePick} />
</div>
)
}
押してください。
PlainChild が呼ばれた: 2 回目
PlainChild が呼ばれた: 3 回目
PlainChild が呼ばれた: 4 回目
useCallbackで包んだ、まったく同じ関数を渡しているのに、PlainChildは毎回呼ばれます。
当たり前です。 PlainChild は memo で包まれていないので、props を比べる処理そのものが存在しません。 親が再描画されたら、無条件で呼ばれます(前回の「きっかけ②」です)。
つまり、この useCallback は:
| 得たもの | 失ったもの | |
|---|---|---|
HeavyChild(memo あり) | 再描画を1回ぶん飛ばせた | わずかな比較コスト |
PlainChild(memo なし) | 何も無い | 依存配列の生成と比較、保存領域 |
memoしていない子にしか渡していないuseCallbackは、100% 損です。 効果ゼロ、コストだけ。 それでも、いちばんよく見かける書き方です。
チェックのしかたは簡単です。
useCallbackを書いたら、その関数を受け取る側のファイルを開いて、memo(があるか目で見る。 無ければ外す。
用途2 — useEffect の依存配列に入れる関数
もう1つ、正当な用途があります。 こちらは速さの話ではありません。
const fetchUser = useCallback(async () => {
const res = await fetch('/api/users/' + userId)
return res.json()
}, [userId])
useEffect(() => {
fetchUser().then(setUser)
}, [fetchUser])
useEffect は、依存配列が変わるたびに中身を実行し直します。 fetchUser を useCallback で包まないと、再描画のたびに fetchUser が別物になり、useEffect が毎回動きます。
無限に通信し続ける画面が、こうして生まれます。
これは「遅い」ではなく「壊れている」です。 だから測るまでもなく必要です。
ただし、useEffect そのものの話(依存配列に何を書くか、そもそも useEffect が要るのか)は、この記事の範囲外です。 ここでは「useCallback の用途は2つあり、片方は速さと無関係」とだけ覚えてください。
⑤ 依存配列が毎回変わると、全部が無意味になる
ここまでで useMemo と useCallback を正しく足せたつもりでも、この落とし穴に落ちると、全部が無かったことになります。
そして、画面は正しく動きます。 だから気付けません。
実演する
src/components/DepsDemo.jsx(新規)
import { useMemo, useState } from 'react'
import { makeItems, topByScore } from '../heavy'
const ITEMS = makeItems(200000)
export default function DepsDemo() {
const [count, setCount] = useState(0)
// ⚠️ 毎回、新しいオブジェクトを作っている
const options = { min: 50000 }
const top = useMemo(() => {
const start = performance.now()
const result = topByScore(ITEMS, options.min)
console.log('★ ソートを実行した:', (performance.now() - start).toFixed(2), 'ms')
return result
}, [options])
return (
<div style={{ padding: '12px', border: '1px solid #ccc' }}>
<button onClick={() => setCount(count + 1)}>カウント: {count}</button>
<p>先頭: {top[0].name}</p>
</div>
)
}
App.jsx を差し替えて、ボタンを3回押してください。
★ ソートを実行した: 61.20 ms
★ ソートを実行した: 60.80 ms
★ ソートを実行した: 62.10 ms
useMemoを書いてあるのに、毎回ソートしています。 ③で消したはずの固まりが、戻ってきています。
理由は ④ とまったく同じです。
const options = { min: 50000 }
この行は、再描画のたびに実行されます。 min の値は毎回 50000 ですが、オブジェクトそのものは毎回新しく作られます。
Object.is({ min: 50000 }, { min: 50000 })
false
useMemo は「依存が変わった」と判断して、律儀に計算し直します。 useMemo は正しく動いています。 間違っているのは、依存配列に入れたものです。
[スクリーンショット: 04_依存配列が毎回変わる.png] useMemo を書いてあるのにボタンを押すたび ★ ソートを実行した が出ている Console を撮ってください。
これが、この記事でいちばん多い事故です。 「
useMemoを書いたから大丈夫」と思っている画面が、実は1回も効いていない。console.logを計算の中に置くまで、誰にも分かりません。
直し方は3つ
どれも「依存配列に、毎回同じ物が並ぶようにする」ためのものです。
直し方① — プリミティブに分解する(いちばん強い)
オブジェクトごと渡すのをやめて、実際に使っている値だけを取り出します。
const options = { min: 50000 }
const top = useMemo(() => {
const start = performance.now()
const result = topByScore(ITEMS, options.min)
console.log('★ ソートを実行した:', (performance.now() - start).toFixed(2), 'ms')
return result
}, [options.min])
変えたのは、依存配列の1箇所だけです。 [options] を [options.min] にしました。
押してください。 ★ が出なくなります。
options.min は数値です。 数値は、中身が同じなら同じ物です。だから比較が通ります。
迷ったら、これです。 依存配列には、なるべく数値・文字列・真偽値だけを並べる。
直し方② — コンポーネントの外に出す
その値が、props にも state にも依存しないなら、そもそもコンポーネントの中で作る必要がありません。
const ITEMS = makeItems(200000)
const OPTIONS = { min: 50000 } // ← 外に出した
export default function DepsDemo() {
const [count, setCount] = useState(0)
const top = useMemo(() => {
// ...
return topByScore(ITEMS, OPTIONS.min)
}, [])
モジュールのトップレベルに書いたものは、読み込み時に1回だけ作られます。 再描画では作り直されません。 だから依存配列に入れる必要すらありません。
useMemoの前に、まずこれを検討してください。 メモ化しなくて済むなら、それがいちばん速いです。
直し方③ — useMemo でオブジェクトを作る
値が state や props から計算される場合は、外に出せません。そのときだけ、オブジェクト自体を useMemo で作ります。
const [threshold, setThreshold] = useState(50000)
const options = useMemo(() => ({ min: threshold }), [threshold])
const top = useMemo(() => {
// ...
return topByScore(ITEMS, options.min)
}, [options])
options は、threshold が変わったときだけ新しくなります。 だから [options] という依存配列が、意味を持つようになります。
ただし、これは
useMemoが2つ並びます。 読みにくいです。 ①か②で済むなら、③は使わないでください。
まとめると
| 依存配列に入っているもの | 効くか |
|---|---|
| 数値・文字列・真偽値 | 効く |
その場で書いたオブジェクト {...} | 効かない |
その場で書いた配列 [...] | 効かない |
その場で書いた関数 () => {} | 効かない |
| モジュールの外で作った定数 | 効く |
useMemo / useCallback で作ったもの | 効く(その依存配列が正しければ) |
useState が返す set...、useReducer が返す dispatch | 効く(前回で見たとおり、React が安定させている) |
⑥ 子に渡すオブジェクトを useMemo で安定させる
⑤の応用です。 React.memo した子にオブジェクトを渡すときも、同じことが起きます。
<HeavyChild config={{ color: 'crimson', size: 14 }} />
このインラインのオブジェクトは、毎回別物です。 memo は効きません。
const config = useMemo(() => ({ color: 'crimson', size: 14 }), [])
// ...
<HeavyChild config={config} />
依存配列が空なので、この config は最初の1回しか作られません。 memo が効くようになります。
この型が、いちばんよく使われるのが Context です。
// ⚠️ これは、Provider の下にいる全員が毎回再描画される
<UserContext.Provider value={{ user, login, logout }}>
// ○ user・login・logout が変わったときだけ、新しくなる
const value = useMemo(() => ({ user, login, logout }), [user, login, logout])
<UserContext.Provider value={value}>
Context を読んでいるコンポーネントは、value が変わるたびに全部再描画されます(前回の「きっかけ③」)。インラインのオブジェクトを渡すと、それが毎回起きます。
Context そのものの話は別の記事でやります。 ここでは「Provider の value は useMemo で包む、という定型がある」とだけ押さえてください。本線の状態管理の回に、Context の基本があります。
なお、これも「測ってから」です。 Provider の下に軽いコンポーネントが3個しかいないなら、包む価値はありません。
⑦ React Compiler — 手で書かなくてよくなる方向
ここまでの作業は、正直に言って、面倒です。
「どこが重いか測って、memo を貼って、useCallback を足して、依存配列を確認する」——これは、機械にできる仕事に見えます。
React チームも、そう考えています。 React Compiler(以前は React Forget と呼ばれていました)は、ビルド時にコードを解析して、必要なメモ化を自動で入れるためのコンパイラです。うまくいけば、useMemo も useCallback も、人が書かなくてよくなります。
2025年10月に安定版(1.0)が出ていますが、この記事では前提にしません。
- すべてのコードに使えるわけではありません。 コンパイラは「フックの規則を守っていること」を前提に解析します(前回でやった規則です)。破っているコードは、コンパイラ側が安全のために最適化を諦めます
- 導入すると、いま動いているものが壊れることがあります。 現場に入れるかどうかは、チームで決める話です
- そして何より、この記事でやったこと自体は無駄になりません。 「何が起きているか分からないまま自動化に任せる」のは、いちばん危険な状態だからです
道具が自動になっても、「なぜ必要だったのか」を知らない人は、壊れたときに直せません。 自動化は、理解の代わりにはなりません。
いまは「そういう方向に進んでいる」とだけ知っておいて、手では書かない方針を続けてください。 結論は変わりません。
⑧ 結論 — 既定は「書かない」
この記事の答えです。
useMemoとuseCallbackは、既定では書きません。
理由を並べます。
| 理由 | 中身 |
|---|---|
| ほとんどの計算は軽い | ③で見たとおり、1万件のソートですら 2ミリ秒。付ければ遅くなる側 |
| 効く条件が狭い | ④で見たとおり、useCallback は memo した子に渡すときだけ。それ以外は損 |
| 黙って無効になる | ⑤で見たとおり、依存配列が毎回変わっていても、画面は正しく動く。壊れたことに気付けない |
| 読みにくくなる | const x = 1 + 1 が const x = useMemo(() => 1 + 1, []) になる。次に読む人の時間を奪う |
| 構造を直すほうが強い | 前回の「state を下げる」「children で渡す」は、コードを1行も増やさずに効く |
足すのは、この順番を全部通ったときだけです。
- Profiler か
performance.now()で測った。 ミリ秒の数字が言える - その数字が、体感できる大きさだった(目安 16ミリ秒以上)
- 構造を直す手(state を下げる /
childrenで渡す)を、先に試した - それでも残ったので、
memo/useMemo/useCallbackを足した - 足したあと、もう一度測って、実際に減ったことを確かめた
5 を飛ばさないでください。 パフォーマンス改善の回で、SQL に索引を張ったあと EXPLAIN で確かめたのと同じです。貼っただけでは、効いたかどうか誰も知りません。
⑨ 足す前のチェックリスト
useMemo か useCallback を書こうとしたら、この4つに答えてください。 1つでも「いいえ」なら、書きません。
| # | 質問 | 「いいえ」なら |
|---|---|---|
| 1 | 測ったか。 その処理が何ミリ秒か、数字で言えるか | 書かない。 まず測る |
| 2 | その数字は、体感できる大きさか(目安 16ミリ秒以上) | 書かない。 軽い計算に付けると遅くなる(③で実測) |
| 3 | (useCallback なら)渡す先は React.memo で包まれているか | 書かない。 効果ゼロ、コストだけ(④で実測) |
| 4 | 依存配列は、毎回同じ物が並ぶか(プリミティブか、安定した参照か) | 書かない。 依存を直すのが先(⑤で実測) |
そして、書いたあとに5つ目があります。
5. 書いたあと、もう一度測って、数字が減ったか。 減っていなければ、消す。
つまずいたところ
最初、1万件のソートで実験を始めて、まったく差が出ませんでした。 useMemo を付けても外しても 2ミリ秒。「useMemo は効かない機能なのでは」と、30分ほど本気で疑いました。 記事も「useMemo は意味がない」という結論で書きかけました。間違っていたのは useMemo ではなく、「1万件は重い」という自分の感覚のほうでした。 計算量の回で n log n を自分で書いていたのに、体感の見積もりが、桁で外れていました。 20万件にした瞬間に、全部が見えました。「効くはずの道具が効かない」と思ったら、まず題材が小さすぎないかを疑うべきでした。
軽い計算の比較で、最初 performance.now() を ROWS.map(...) に巻いていました。 useMemo あり・なしで差が出ず、「同じだ」という結論を一度出しかけました。③に書いたとおり、そこでは useMemo がまだ動いていなかったのです。useMemo のしていることを bench.mjs で直接回したら、10.8ms と 80.5ms ではっきり差がありました。 測れていないことと、差が無いことは、まったく別です。何を測っているのかを確認せずに「差が無い」と言うのは、測っていないのと同じでした。
useCallback を付けたのに memo が効かない、で1時間溶かしました。 子に onPick と一緒に style={{ padding: 4 }} も渡していたからです。onPick は安定していたのに、style が毎回別物でした。props は1つでも変われば「変わった」です。 useCallback だけ見て「これで安定した」と思い込み、同じ行に書いてある別の props を見ていませんでした。 直し方は簡単で、console.log で props を全部出して、前回のものと1つずつ Object.is で比べるだけでした。「関数だけ気にする」癖が付いていたのが原因です。
memo していない子に useCallback した関数を渡している自分のコードが、前のプロジェクトに大量にありました。 この記事を書きながら数えたら、14箇所ありました。全部、効果ゼロでコストだけです。当時は「関数は useCallback で包むもの」という覚え方をしていました。 「いつ使うか」ではなく「どう書くか」だけを覚えると、こうなります。
依存配列に options を入れて毎回再計算していたコードは、半年間、誰も気付きませんでした。 画面は正しく動いていたからです。useMemo の中に console.log を1行入れるまで、効いているものだと思っていました。 メモ化が壊れても、エラーは1つも出ません。 黙って遅いだけです。「書いてあるから効いている」は、成り立ちません。
eslint の警告を消すために、依存配列から変数を手で削ったことがあります。 警告は消えて、動いているように見えて、数日後に「たまに古い値が表示される」というバグになりました。 eslint-plugin-react-hooks が依存配列について言うことは、ほぼ正しいです。警告を消すために配列をいじるのではなく、警告どおりに入れて、それで再計算が増えるなら「入れる物のほうを安定させる」(⑤の3つの直し方)が正解でした。
後片づけ
開発サーバーを止める
起動しているターミナルで Ctrl+C。
確認: 何も出なければ、止まっています。
ポートを閉じる
開けっぱなしにしません。
確認: 5176/tcp の行が消えていれば成功です。5173番は、本線で使うので残してあります。
プロジェクトをどうするか
~/reactlab/ は、消しても消さなくても構いません。
残す場合、node_modules が数百MBあります。中身は package.json から復元できるので、容量が気になるなら消して構いません。
戻すときは cd ~/reactlab && npm install だけです。この考え方はnpmの回にあります。
丸ごと消す場合。
~/react-demo/ は絶対に消さないでください。 本線がその続きで進みます。
確認: 本線のファイル一覧が出れば、無事です。
まとめ
useMemoは計算を消していない。 「前回の結果と交換する」だけで、比較と保存のコストが必ず上乗せされる- 1万件のソートは 2ミリ秒だった。 付ける理由にならない。 20万件で 60ミリ秒になって、初めて理由ができた
useMemoを付けても、必要な回は 60ミリ秒かかる。 速くなったのではなく、やらなくていい回を飛ばしただけuseMemoが内部でやることを素の JS で500万回まわすと、計算だけ 10.8ms に対してuseMemo相当は 80.5ms だった。 アロー関数の生成 + 依存配列の生成と比較 + 保存領域が上乗せされる- 判断基準は「実測 16ミリ秒以上」。 1ミリ秒未満には、絶対に付けない
useCallbackは関数の実行を速くしない。 関数を毎回作り直さないようにするだけmemoした子に渡す関数は、useCallbackで包まないとmemoが効かない。Object.is(() => 1, () => 1)はfalse- 仕事をしているのは
React.memoのほう。useCallbackは、memoが働ける条件を整えているだけ memoしていない子にしか渡さないuseCallbackは、効果ゼロでコストだけ。 受け取る側のファイルにmemo(があるか、目で確かめる- もう1つの用途は
useEffectの依存配列。 包まないと毎回別物になり、無限に通信し続ける。 こちらは速さではなく壊れる話 - 依存配列にその場で書いたオブジェクト・配列・関数を入れると、毎回別物なので、メモ化が全部無効になる
- 無効になっても、画面は正しく動く。エラーも出ない。
console.logを中に置くまで、誰も気付けない - 直し方は3つ。①プリミティブに分解する(
[options]→[options.min])②コンポーネントの外に出す ③useMemoでオブジェクトを作る - ①か②で済むなら、③は使わない。
useMemoが2つ並ぶと、読めなくなる set...とdispatchは、React が安定させているので依存配列に入れても問題ない- Context の
valueはuseMemoで包むのが定型。 インラインのオブジェクトを渡すと、下にいる全員が毎回再描画される - React Compiler(2025年10月に安定版 1.0)が自動化を進めている。 ただし、まだ前提にしない。 自動化は理解の代わりにならない
- 既定は「書かない」。 測って、遅くて、構造を直しても残って、原因がこれだと分かったときにだけ足す
- 足したら、もう一度測る。 減っていなければ、消す
参考リンク
- roadmap.sh — React
- React 公式 — useMemo
- React 公式 — useCallback
- React 公式 — memo
- React 公式 — 再レンダリングを飛ばす
- React 公式 — React Compiler
- React 公式 — フックの規則
- MDN — performance.now
- MDN — Object.is
- eslint-plugin-react-hooks
- Vite 公式ガイド
次に読む
この記事は 【深掘り】React の 6 / 24 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | useEffect — その多くは要らない |
| → 次の記事 | useRefの2つの用途 — 中身がnullで落ちる |
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- useMemo / useCallback は測ってから足す
- 依存配列の同一性
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント