useMemoとuseCallback — 付けるほど遅くなる

useMemoとuseCallback。ストップウォッチと性能のメーター、結果を保存する箱。

useMemoとuseCallbackは、付けるほど速くなるものではありません。効く条件と、かえって遅くなる場合を測って確かめます。

前回: useEffect — その多くは要らない

これは深掘りです。本線の順路ではありません。 本線のコンポーネントと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)。ただし、この記事では前提にしない

この記事でやること

  1. ~/reactlab/ を新しく作り、ポート 5176 で起動する
  2. performance.now() で「実際に何ミリ秒かかっているか」を先に測る
  3. 20万件のソートに useMemo を付けた前後を実測し、次に軽い計算に付けて逆に遅くなることを実測する
  4. React.memo した子に関数を渡し、useCallback の有無でログの回数が変わるところを見る
  5. 依存配列にオブジェクトを入れて、メモ化が全部無効になるところを再現し、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の中で、ホームディレクトリに戻って作ります。

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

質問が出たら、そのまま Enter で構いません。 版によっては「このまま npm install して起動しますか?」と聞かれます。そこは No(n)を選んでください。 ポートを自分で決めたいからです。

bash
$ cd ~/reactlab
$ npm install
$ ls
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番でやります。

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

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

5176/tcp の行が出れば準備完了です。開けずに起動すると、ターミナルには「起動しました」と出るのに、ブラウザは読み込み中のままになります。「ポートが開いていない」ことは、ブラウザ側からは「サーバーが無い」ようにしか見えません。

起動する

bash
$ npm run dev -- --host 0.0.0.0 --port 5176

ホストの 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 を入れていない場合は、前回の記事に入れ方があります。

  1. F12 → Profiler タブ
  2. 左上の青い丸(記録開始)を押す
  3. 画面を何回か操作する
  4. もう一度丸を押して記録を止める

棒が長いコンポーネントが、遅いコンポーネントです。そこ以外は、この記事の対象ではありません。

「なんとなく重い気がする」で useMemo を足すのを、この記事では禁止にします。 足す前に、必ずミリ秒の数字を1つ持ってください。


③ useMemo が効く条件は、思っているより狭い

まず「効く場合」を作ります。 効く場合を1回も見ずに「使うな」と言われても、納得できないからです。

本当に重い計算を作る

src/heavy.js を新規作成します。

bash
$ cd ~/reactlab

ファイルの中身は 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行も増やさずに効く

足すのは、この順番を全部通ったときだけです。

  1. Profiler か performance.now() で測った。 ミリ秒の数字が言える
  2. その数字が、体感できる大きさだった(目安 16ミリ秒以上)
  3. 構造を直す手(state を下げる / children で渡す)を、先に試した
  4. それでも残ったので、memo / useMemo / useCallback を足した
  5. 足したあと、もう一度測って、実際に減ったことを確かめた

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。

bash
$ ss -ltnp | grep 5176

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

ポートを閉じる

開けっぱなしにしません。

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

確認: 5176/tcp の行が消えていれば成功です。5173番は、本線で使うので残してあります。

プロジェクトをどうするか

~/reactlab/ は、消しても消さなくても構いません。

残す場合、node_modules が数百MBあります。中身は package.json から復元できるので、容量が気になるなら消して構いません。

bash
$ du -sh ~/reactlab/node_modules
$ rm -rf ~/reactlab/node_modules

戻すときは cd ~/reactlab && npm install だけです。この考え方はnpmの回にあります。

丸ごと消す場合。

bash
$ rm -rf ~/reactlab

~/react-demo/ は絶対に消さないでください。 本線がその続きで進みます。

bash
$ ls ~/react-demo/src

確認: 本線のファイル一覧が出れば、無事です。


まとめ

  • 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)が自動化を進めている。 ただし、まだ前提にしない。 自動化は理解の代わりにならない
  • 既定は「書かない」。 測って、遅くて、構造を直しても残って、原因がこれだと分かったときにだけ足す
  • 足したら、もう一度測る。 減っていなければ、消す

参考リンク


次に読む

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

記事
← 前の記事useEffect — その多くは要らない
→ 次の記事useRefの2つの用途 — 中身がnullで落ちる

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

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

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

Frontend›React — Memoization
  • useMemo / useCallback は測ってから足す
  • 依存配列の同一性

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

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

コメント

コメントする

目次