パフォーマンス

Custom Hooks完全ガイド──Reactでロジックを再利用しコンポーネントを超DRY

techgrowup — Mon, 05 May 2025 11:00:00 +0000

はじめに

React 公式チュートリアルでも強調される「コンポーネントは UI を、Hooks はロジックを記述する」という原則。しかし現場のコードベースでは、似たような副作用や状態初期化ロジックを複数コンポーネント間でコピペしてしまうことが珍しくありません。Custom Hook を導入すると、共通処理を 1 箇所でテスト・保守でき、UI コンポーネントは宣言的に保たれます。本記事では公式ドキュメント https://react.dev/learn/reusing-logic-with-custom-hooks をベースに、基礎から高度なパターン、テスト、パフォーマンス、型安全まで徹底解説します。

Custom Hooks の基本構文

import { useState, useEffect } from 'react';

export function useClock() {
  const [time, setTime] = useState(() => new Date());

  useEffect(() => {
    const id = setInterval(() => setTime(new Date()), 1000);
    return () => clearInterval(id);
  }, []);

  return time;
}

関数名は use から始める
ビルトイン Hook は通常どおり使用可能
依存配列は呼び出し元コンポーネントではなく、Hook 内部で完結

よくあるアンチパターン: カスタムフックの中で条件付きフック呼び出し

function useWrong(flag) {
  if (flag) {
    // これはルール違反: フックはトップレベルで呼ぶ必要がある
    useEffect(() => console.log('Bad'), []);
  }
}

React のルールオブフックスに違反し、レンダー順序が崩れる可能性があります。必ずトップレベルで呼び、条件分岐は内部で処理を早期リターンするなどで対応しましょう.

事例1: API フェッチロジックの共通化

ネットワーク通信は多くの画面で発生するため、抽象化すると保守負荷が激減します。

import { useState, useEffect } from 'react';

export function useFetch(url, options) {
  const [status, setStatus] = useState('idle');  // idle | loading | success | error
  const [data, setData]   = useState(null);
  const [error, setError] = useState(null);

  useEffect(() => {
    let ignore = false;
    const controller = new AbortController();

    async function start() {
      setStatus('loading');
      try {
        const res = await fetch(url, { ...options, signal: controller.signal });
        if (!res.ok) throw new Error(res.statusText);
        const json = await res.json();
        if (!ignore) {
          setData(json);
          setStatus('success');
        }
      } catch (e) {
        if (!ignore) {
          setError(e);
          setStatus('error');
        }
      }
    }
    start();

    return () => {
      ignore = true;
      controller.abort();
    };
  }, [url, JSON.stringify(options)]);

  return { status, data, error };
}

ポイント解説

AbortController でコンポーネントのアンマウント時にリクエストを中断
依存配列に options がオブジェクトの場合は JSON.stringify で比較簡略化
status を文字列列挙にすることで UI が状態ごとに切り替えやすくなる

事例2: フォーム入力とバリデーション

React Hook Form や Formik を使わずに軽量に済ませたい場合、以下のような useForm フックを自作できます。

export function useForm(initial) {
  const [values, setValues] = useState(initial);
  const [errors, setErrors] = useState({});

  const onChange = (e) => {
    const { name, value } = e.target;
    setValues(v => ({ ...v, [name]: value }));
  };

  const validate = (rules) => {
    const newErrors = {};
    for (const key in rules) {
      const error = rules[key](values[key]);
      if (error) newErrors[key] = error;
    }
    setErrors(newErrors);
    return Object.keys(newErrors).length === 0;
  };

  const reset = () => setValues(initial);

  return { values, errors, onChange, validate, reset };
}

使用例

function Signup() {
  const { values, errors, onChange, validate } = useForm({ email: '', pw: '' });

  const handleSubmit = () => {
    if (validate({
      email: v => /@/.test(v) ? '' : 'メールが不正',
      pw: v => v.length >= 8 ? '' : '8文字以上必要'
    })) {
      // 送信
    }
  };
  return (/* JSX */);
}

パフォーマンスとメモ化のベストプラクティス

Custom Hook 内で useMemo や useCallback を使う場面:

計算コストが高いロジックをキャッシュ
子に渡すコールバックを安定参照に
オブジェクトや配列を返す場合—参照が変わると下位ツリーが再レンダー

function usePagination(total, perPage) {
  const pageCount = useMemo(() => Math.ceil(total / perPage), [total, perPage]);
  return pageCount;
}

TypeScriptとの組み合わせ

Custom Hook の戻り値がオブジェクトの場合、ジェネリクスで型の再利用性を高められます。

function useToggle<S extends string>(on: S, off: S) {
  const [state, setState] = useState<S>(off);
  const toggle = () => setState(s => s === on ? off : on);
  return { state, toggle };
}

const { state } = useToggle<'on' | 'off'>('on', 'off');

テスト戦略

@testing-library/react-hooks を用いると、Hook 単体をテストできます。

import { renderHook, act } from '@testing-library/react';
import { useCounter } from './useCounter';

test('カウンタが増える', () => {
  const { result } = renderHook(() => useCounter());
  act(() => result.current.inc());
  expect(result.current.count).toBe(1);
});

高度: イベントリスナーを扱う useEventListener フック

DOM イベントを登録・解除するロジックはほぼすべての SPA で必要です。以下の汎用フックをプロジェクトに追加すると、スクロール監視やキー入力検知を簡単に組み込めます。

import { useEffect, useRef } from 'react';

export function useEventListener(type, handler, target = window) {
  const saved = useRef();

  useEffect(() => {
    saved.current = handler;
  }, [handler]);

  useEffect(() => {
    const el = target?.current || target;
    if (!el?.addEventListener) return;
    const listener = (e) => saved.current(e);
    el.addEventListener(type, listener);
    return () => el.removeEventListener(type, listener);
  }, [type, target]);
}

利用例: Escape キーでモーダルを閉じる

function Modal({ onClose }) {
  useEventListener('keydown', e => {
    if (e.key === 'Escape') onClose();
  });
  /* ... */
}

React 18 Concurrent Rendering と Custom Hooks

中断と再実行

並列レンダーではコンポーネントが「途中で止まって再開」される可能性があります。Custom Hook 内で 副作用をレンダーフェーズに書くとバグの温床 になります。

NG: useMemo(() => performSideEffect(), [])
OK : useEffect 内で副作用を実行し、クリーンアップを返す

スケルトン UI の設計

useSuspenseQuery などデータフェッチ Hook を利用するときは、サスペンス発火タイミングを想定しローディングプレースホルダを計画的に配置しましょう。

パフォーマンス計測: React Profiler で Hook のコストを可視化

React DevTools の Profiler タブを開き「Record」
画面操作を実行
Flamegraph または Ranked view で再レンダー時間を検査
Custom Hook 導入前後で差分を比較

重い計算が Commit フェーズに長く表示される場合は useMemo、頻繁なレンダーが Render フェーズに点在する場合は useCallback や React.memo との併用を検討します。

他ライブラリの Custom Hook パターン

TanStack Query: useQuery, useMutation
Redux Toolkit: useSelector, useDispatch
Zustand: useStore(selector)

カスタム Hook のドキュメントとディスカバビリティ

大規模チームでは「どんな Hook があるか分からない」問題が発生します。

命名規約：機能＋動詞 (useFetchUser, useDebouncedValue)
Storybook Docs: Hook 用ストーリを作り動作を可視化
JSDoc/TSDoc と例コードを README に添付

落とし穴と対策一覧

症状	原因	対処
無限ループ	依存配列にオブジェクトリテラル	`useMemo` で固定 or JSON.stringify
stale data	依存配列抜け漏れ	ESLint `exhaustive-deps`
メモリリーク	useEffect 内でクリーンアップ忘れ	必ず return で解除
フックのネスト深すぎ	抽象化不足/責務過多	Hook を小さく分割

いまさら聞けない React ルールオブフックス

トップレベルでのみ呼ぶ
関数コンポーネント or Custom Hook 内で呼ぶ

エラーハンドリング: useSafeAsync フック

function useSafeAsync(fn, deps = []) {
  const mounted = useRef(true);
  useEffect(() => {
    mounted.current = true;
    fn().catch(console.error);
    return () => (mounted.current = false);
  }, deps);
  const safeSet = updater => {
    if (mounted.current) updater();
  };
  return safeSet;
}

フックファクトリパターン

function createUseApi(base) {
  return function useApi(path) {
    return useFetch(base + path);
  };
}
const useGitHub = createUseApi('https://api.github.com');

まとめ

この記事では Custom Hook の意義から実装、型安全、テスト、パフォーマンス、外部 API 連携、アクセシビリティまで幅広く網羅しました。これらのノウハウを活かし、あなたの React プロジェクトを 再利用性が高く、バグが少なく、パフォーマンスに優れた コードベースへ進化させてください。

useMemo徹底ガイド──Reactアプリの再計算コストを劇的に減らす最適化テクニック

techgrowup — Wed, 30 Apr 2025 23:00:00 +0000

useMemoとは何か

useMemo は指定した計算式をメモ化（キャッシュ）し、依存配列が変わらない限り再実行をスキップするReactフックです。たとえば数千件のリストを高コストなフィルタリングやソートで描画する場合、入力が変わらなければ同じ結果を再計算するのはムダです。useMemo を使えば計算を一度だけ行い、次回レンダーではキャッシュ済みの値を返すため描画が高速化します。

import { useMemo } from 'react';

function ExpensiveList({ items, query }) {
  const filtered = useMemo(() => {
    return items.filter(item => item.name.includes(query));
  }, [items, query]); // itemsかqueryが変わったときだけ再計算

  return filtered.map(item => <li key={item.id}>{item.name}li>);
}

基本シグネチャ

const memoizedValue = useMemo(() => compute(expensive), [deps]);

第1引数：メモ化したい関数（副作用を含まない純粋関数が望ましい）。
第2引数：依存配列。ここに列挙した値が変わった場合のみ計算し直す。

依存配列を空配列 [] にするとマウント時に一回だけ実行。undefined を渡すと毎レンダー実行＝メモ化無効なので注意。

useMemoが効く典型シナリオ

1. データ変換・重い計算

数学的シミュレーションの結果
JSONデータのディープコピーや正規化
Markdown → HTML 変換など CPUコストが高い処理

2. フィルタ・ソート・検索

リストの要素数が数百〜数千を超える場合、Array.prototype.filter や sort を毎レンダー走らせるとフレーム落ちの原因になります。

3. JSX生成コスト削減

巨大リストを map で JSX に展開するとき、その戻り値をメモ化すると描画コストを下げられます（React 18の並列レンダーでも効果的）。

useCallbackとの違い

観点	useMemo	useCallback
目的	値をメモ化	関数参照をメモ化
戻り値	計算結果そのもの	メモ化済みの関数
主要用途	高コストの計算結果を保持	子コンポーネントへ渡すハンドラの参照固定

内部実装では useCallback(fn, deps) は useMemo(() => fn, deps) と同等です。しかし意味づけが異なるため、値なら useMemo、関数なら useCallback を使うと読みやすくなります。

実践シナリオ別コード例

例1：検索フィルタリング

function SearchableTable({ rows }) {
  const [keyword, setKeyword] = useState('');
  const visibleRows = useMemo(() => {
    const lower = keyword.toLowerCase();
    return rows.filter(r => r.name.toLowerCase().includes(lower));
  }, [rows, keyword]);
  return (
    <>
      <input value={keyword} onChange={e => setKeyword(e.target.value)} />
      <ul>{visibleRows.map(r => <li key={r.id}>{r.name}li>)}ul>
    
  );
}

rows が巨大でも keyword が変わらなければ再計算なし
入力ごとにフィルタされても実用レベルのパフォーマンス

例2：高コスト画像処理

function Preview({ file }) {
  const thumbnail = useMemo(() => {
    return file ? createThumbnail(file) : null; // Canvas処理など重い関数
  }, [file]);
  return thumbnail ? <img src={thumbnail} /> : null;
}

例3：ソート済みキャッシュ

const sorted = useMemo(
  () => [...items].sort((a, b) => a.date - b.date),
  [items]
);

イミュータブルデータならシャローコピーしてソートし、items が同一参照の間は再計算されません。

依存配列設計のコツ

リストやオブジェクトは参照が変わる条件を把握
- Redux/Context でステートが再生成されると参照が毎回変わる ⇒ 先にuseSelector(shallowEqual)などで固定化
不要な依存を追加しない
- 計算結果に影響しない値を含めると再実行が増える
入れ忘れはバグの温床
- ESLintのreact-hooks/exhaustive-depsルールを有効化し、自動検出する

// NG: setState関数は安定参照のため依存不要
useMemo(() => compute(state, setState), [state, setState]); 
// OK
useMemo(() => compute(state), [state]);

パフォーマンス測定と検証

Profiler API

React DevTools を開き「Profiler」タブを選択
録画して操作 ⇒ 再計算が走る場所を特定
useMemo導入後にレンダー時間が短縮されているか確認

console.time計測

const result = useMemo(() => {
  console.time('expensive');
  const v = heavy();
  console.timeEnd('expensive');
  return v;
}, [deps]);

メモ化の前後で時間を比較し、効果を数字で把握します。

よくある落とし穴

症状	原因	対策
メモ化しているのに速くならない	計算自体が軽い／依存が毎回変わる	メモ化を外す or 依存を安定化
stale data（古い値を参照）	依存配列に必要な変数がない	ESLintルールで検出＋修正
メモリリーク	大きな配列・Mapをキャッシュして解放しない	必要に応じて `useMemo` を解除

useMemoを使わない方がいい場合

計算コスト < メモ化管理コスト
UIがほぼ静的：再レンダー回数が少ない
依存が頻繁に変わる：キャッシュがほぼ活きない

最適化は「必要になったら測定して導入」が鉄則です。

`useMemo` と Suspense / Concurrent Features

React 18 の並列レンダーでは、useMemoのキャッシュが中断と再開をまたいで保持されるため、長い計算でもUIスレッドをブロックしにくくなっています。ただしメモ化対象関数は同期的に実行されるため、CPU負荷の高い処理はWeb WorkerやuseTransitionと組み合わせるとさらに快適です。

まとめ

useMemo は

高コスト計算の結果をキャッシュし
依存配列が変わるまで再利用し
不要な再レンダーを抑制

というシンプルながら強力な最適化手段です。ただし「とりあえず入れる」は逆効果。まずはプロファイリングでボトルネックを特定し、効果が見込める箇所にのみ導入するのがベストプラクティスです。正しい依存配列と計算粒度を意識し、快適なReact UIを届けましょう。

ReactのuseCallback徹底ガイド──依存配列・再レンダリング制御・パフォーマンス最適化の基本と応用

techgrowup — Sun, 27 Apr 2025 23:00:00 +0000

はじめに

Reactの関数コンポーネントで副作用や再レンダリング制御を扱う際、useCallback フックはしばしば「面倒くさい」「よくわからない」と敬遠されがちです。しかし、大規模アプリのパフォーマンスチューニングや、子コンポーネントへのコールバック関数渡しを正しく行うためには不可欠な存在です。本記事では基礎から依存配列の書き方、内部動作、注意点、具体的な活用シーンまでを解説します。

useCallbackとは？

useCallback は「関数をメモ化（キャッシュ）する」ための React フックです。コンポーネントが再レンダーされるたびに新しい関数インスタンスを生成すると、子コンポーネントに渡したコールバックが”変化”とみなされ、不要な再レンダーにつながります。これを防ぐのが useCallback です。

const memoizedHandler = useCallback(() => {
  console.log('クリックされました');
}, [依存値1, 依存値2]);

第1引数：メモ化したい関数
第2引数：依存配列。ここに入れた値が変わると新しく関数を作り直す

基本シグネチャと戻り値

function useCallback<T extends (...args: any[]) => any>(
  callback: T,
  deps: DependencyList
): T;

T：任意の関数型
DependencyList：any[] 型の配列
戻り値：渡した callback と同じ型の“メモ化された関数”

内部では React が Hook ごとに前回の callback 参照を保持し、deps が完全一致する限り同じ関数を返します。

依存配列の正しい書き方

依存配列を適切に指定しないと、次のような問題が起きます。

誤り	症状
依存配列を空にする (`[]`)	最新の外部変数を参照できない（stale closure）
依存を省略 (`undefined`)	毎回新しい関数が作られ、効果なし
必要な依存を含めない	古い値を使い続ける

例：カウントを依存に含めないと古い値を参照する

function Counter() {
  const [count, setCount] = useState(0);

  const handler = useCallback(() => {
    console.log(count); // 依存にcountを含めないと常に0が表示
  }, []); 

  return <button onClick={handler}>ログ出力button>;
}

上記では count が変わっても handler 内の count は初回のまま。依存配列には常に最新のcountを正しく指定しましょう。

useCallbackとuseMemoの違い

useCallback：関数をメモ化する
useMemo：関数の戻り値（任意の値）をメモ化する

const memoizedValue = useMemo(() => computeExpensive(a, b), [a, b]);
const memoizedHandler = useCallback(() => doSomething(a, b), [a, b]);

useCallback(fn, deps) は useMemo(() => fn, deps) のエイリアスと考えることもできますが、可読性の観点から関数キャッシュには useCallback を使うのが一般的です。

コンポーネント初回レンダー
useCallback が新しい関数を生成し返却
次回レンダー
- deps が同じ → 前回の関数を再利用
- deps が変わった → 新しい関数を生成
子コンポーネントへ渡す際、関数参照の変化を検出してレンダー制御できる

この仕組みを利用し、React.memo と組み合わせることで子コンポーネントの再レンダーを抑制できます。

子コンポーネントの最適化例

const Child = React.memo(({ onAction }) => {
  console.log('Child render');
  return <button onClick={onAction}>アクションbutton>;
});

function Parent() {
  const [count, setCount] = useState(0);

  const handleAction = useCallback(() => {
    console.log('Action!');
  }, []); // 依存なし → 再レンダー時も同じ参照

  return (
    <>
      <p>Count: {count}p>
      <button onClick={() => setCount(c => c + 1)}>増やすbutton>
      <Child onAction={handleAction} />
    
  );
}

Parent が再レンダーされても handleAction は同じ参照
Child は Props が変わらないとレンダーされないため高速

使わないほうがいいケース

軽量コンポーネント／関数
関数の生成コストよりReactのレンダーコストのほうが低い場合
短命な値
毎回異なる依存配列を生成すると逆効果
過度のメモ化
コードが複雑になり可読性や保守性が低下

判断基準：
パフォーマンス問題が「本当に関数参照の変化」に起因しているかプロファイラで確認しましょう。

複数フックとの連携パターン

useCallback + useEffect

エフェクト内で関数を参照する場合、依存配列に含めないと stale closure が起きます。

function Search({ query }) {
  const [results, setResults] = useState([]);
  const fetchResults = useCallback(async () => {
    const res = await fetch(`/api?q=${query}`);
    setResults(await res.json());
  }, [query]);

  useEffect(() => {
    fetchResults();
  }, [fetchResults]); // fetchResults を正しく依存に含める

  return /* 結果表示 */;
}

useCallback + useMemo

関数による計算結果をさらにメモ化したい場合

const expensiveCompute = useCallback((x) => heavyCalc(x), []);
const memoizedResult = useMemo(() => expensiveCompute(input), [input, expensiveCompute]);

useCallback でメモ化された関数をテストする際は、renderHook と act を使うと楽です。

コールバック関数のテスト

useCallback でメモ化された関数をテストする際は、renderHook と act を使うと楽です。

import { renderHook, act } from '@testing-library/react-hooks';

test('fetchResults が更新時に変化する', async () => {
  const { result, rerender } = renderHook(
    ({ query }) => useCallback(/*…*/, [query]),
    { initialProps: { query: 'a' } }
  );
  const first = result.current;
  rerender({ query: 'b' });
  expect(result.current).not.toBe(first);
});

パフォーマンス計測とベンチマーク

Profiler API で実際のレンダー回数を計測
React DevTools のProfilerタブでコールバック関数生成の影響を見る
useCallback 無し / 有りでどれだけ再レンダーが減るかを数値で比較

よくある誤解とQ&A

「depsが空なら一度だけ実行される」
→ useCallback では「関数参照が一度だけ生成される」。 useEffect([], …) とは別。
「関数を渡すだけで最適化される」
→ 子コンポーネントも React.memo などで参照比較しなければ効果なし。
「常に使えば良い」
→ 過度のメモ化は逆効果。必要な箇所だけに絞りましょう。

まとめ

useCallback は関数インスタンスの再生成を防ぎ、再レンダーを制御する強力なフックです。依存配列の正確な管理、React.memo との併用、過度なメモ化の回避などポイントを押さえれば、アプリ全体のパフォーマンスが向上します。まずはパフォーマンスプロファイリングを行い、本当に必要な箇所だけに導入してみてください。

Reactエフェクトのライフサイクル完全ガイド──useEffectがいつ動く？依存関係・クリーンアップ・タイミングを徹底解説

techgrowup — Sun, 27 Apr 2025 19:00:00 +0000

はじめに

Reactコンポーネントで副作用（データ取得・購読・手動DOM操作等）を扱う際の要がuseEffectフックです。しかし「いつ呼ばれるのか」「どこでクリーンアップすべきか」「依存配列の指定をどう書くべきか」を誤解しやすく、バグや無限ループ、不要な再実行に悩む開発者は少なくありません。本稿ではuseEffectとuseLayoutEffectのライフサイクルを丁寧に紐解き、実践的なコード例とともに解説します。

Reactエフェクトの基本概念

エフェクト（副作用）とは、ReactのUI更新の外側で起きる処理全般を指します。具体例としては：

外部APIからデータを取得する
WebSocketやイベントリスナーを登録・解除する
手動でDOMを操作する（サードパーティライブラリ連携）

useEffectフックは、レンダー後に“副作用”を実行し、必要ならクリーンアップ（解除）も指定できる仕組みです。

import { useEffect } from 'react';

function Example({ url }) {
  useEffect(() => {
    fetch(url).then(r => r.json()).then(data => {
      console.log(data);
    });
  }, [url]);
  return <div>データを取得中…div>;
}

第1引数：エフェクト用コールバック
第2引数：依存配列。中身が変わったときだけ再実行

ライフサイクルフロー全体像

マウント後：最初のレンダーが完了した直後に実行
更新後：依存配列の値が前回と異なるとレンダー後に再実行
アンマウント前：前回のエフェクトで返したクリーンアップ関数を実行
依存配列なし：マウント後のみ実行、更新時には再実行されない
依存配列を省略：レンダーごとに実行し、旧エフェクトは都度クリーンアップ

以下、各ステップを深掘りします。

マウント後の初回実行

useEffect(fn, deps) は マウント直後 にまず実行されます。DOMが構築された後なので、document.getElementById など直接DOM操作しても正しく参照できるタイミングです。

function InitLogger() {
  useEffect(() => {
    console.log('コンポーネントが画面に追加されました');
  }, []); // 依存配列空でマウント後のみ
  return <div>初期化ログを出力div>;
}

依存配列を空にすると、初回レンダー後だけに限定
一度きりのサブスクリプションやログに最適

依存配列による再実行制御

依存配列 ([a, b, …]) に指定した値が前回と異なる場合、更新後に再実行されます。

function Fetcher({ userId }) {
  const [profile, setProfile] = useState(null);
  useEffect(() => {
    let active = true;
    fetch(`/api/users/${userId}`)
      .then(r => r.json())
      .then(data => {
        if (active) setProfile(data);
      });
    return () => { active = false }; // クリーンアップ
  }, [userId]); 
  // userIdが変わるたびに実行／前回のフェッチはキャンセル
  return profile ? <UserCard data={profile} /> : <p>読み込み中…p>;
}

古いフェッチ結果を書き込まないためのフラグ制御
依存の追加漏れが無限ループや stale closure を招く

クリーンアップ関数の重要性

エフェクト内で何らかの購読（Subscription）やタイマーを登録した場合、コンポーネントの破棄前に必ず解除する必要があります。useEffectのコールバックが返す関数がクリーンアップに該当します。

function Clock() {
  const [time, setTime] = useState(Date.now());
  useEffect(() => {
    const id = setInterval(() => setTime(Date.now()), 1000);
    return () => clearInterval(id); // アンマウント時に解除
  }, []);
  return <div>現在時刻：{new Date(time).toLocaleTimeString()}div>;
}

クリーンアップがないと、メモリリークや不要なタイマーが残り続ける
レンダーごとに再登録してしまう実装ミスにも注意

`useLayoutEffect`と`useEffect`の違い

useEffect：レンダー後に非同期的に実行される
useLayoutEffect：レンダー直後、ブラウザの描画前に同期的に実行される

レイアウトやサイズ計算をDOMに対して行う場合は、レイアウトズレを防ぐために useLayoutEffect を使います。それ以外は通常の useEffect を優先しましょう。

import { useLayoutEffect, useRef } from 'react';

function MeasureBox() {
  const ref = useRef();
  useLayoutEffect(() => {
    console.log(ref.current.getBoundingClientRect());
  }, []);
  return <div ref={ref}>サイズを測定div>;
}

副次的レンダーとスケジューリング

React 18では厳格モード（Strict Mode）使用時に、開発中の副作用が2回実行される仕様があります。これは初回マウント→アンマウント→再マウントの動きを通して、クリーンアップ漏れを早期に検出するためです。本番ビルドでは1回だけ実行されますが、開発体験向上のため注意して実装しましょう。

パフォーマンス最適化パターン

依存配列の最小化
不要な変数を入れると再実行が多発。逆に入れ忘れると stale data の原因。
useCallback / useMemo
エフェクト中で関数や計算結果を依存させる場合はメモ化して参照の安定化を図る。
サブスクリプション分離
複数の副作用を一つの useEffect にまとめず、責務ごとに分けると、不要な再実行を抑えやすい。

useEffect(() => { /* データ取得 */ }, [id]);
useEffect(() => { /* 購読登録 */ }, [socket]);

よくある落とし穴と対策

症状	原因	対策
無限ループ	依存配列に頻繁に変わる値が含まれる	必要最小限の依存に絞る
クリーンアップ漏れ	return を忘れた	購読/タイマーは必ず return で解除
stale closure（古い状態を参照）	クロージャ内で古い変数を直接参照	依存配列に必要な値をすべて含める、またはフラグ制御
レンダリング前の計測ずれ	useEffectでDOM計測	useLayoutEffectに移行

実践例：データフェッチ×キャンセルパターン

import { useState, useEffect } from 'react';

function SearchResults({ query }) {
  const [results, setResults] = useState([]);
  useEffect(() => {
    const controller = new AbortController();
    fetch(`/api/search?q=${encodeURIComponent(query)}`, { signal: controller.signal })
      .then(r => r.json())
      .then(setResults)
      .catch(err => {
        if (err.name !== 'AbortError') console.error(err);
      });
    return () => controller.abort(); // クエリ変更時・アンマウント時に中断
  }, [query]);
  return (
    <ul>
      {results.map(r => <li key={r.id}>{r.title}li>)}
    ul>
  );
}

まとめ

Reactの副作用ライフサイクルを正しく理解すると、UI更新と非同期処理、リソース管理がスムーズになります。useEffectとuseLayoutEffectの使い分け、依存配列の設計、クリーンアップの徹底、パフォーマンス最適化パターンをマスターし、副作用バグから解放された堅牢なコンポーネントを開発しましょう。

パフォーマンス

Custom Hooks完全ガイド──Reactでロジックを再利用しコンポーネントを超DRY

はじめに

Custom Hooks の基本構文

よくあるアンチパターン: カスタムフックの中で条件付きフック呼び出し

事例1: API フェッチロジックの共通化

ポイント解説

事例2: フォーム入力とバリデーション

使用例

パフォーマンスとメモ化のベストプラクティス

TypeScriptとの組み合わせ

テスト戦略

高度: イベントリスナーを扱う useEventListener フック

利用例: Escape キーでモーダルを閉じる

React 18 Concurrent Rendering と Custom Hooks

中断と再実行

スケルトン UI の設計

パフォーマンス計測: React Profiler で Hook のコストを可視化

他ライブラリの Custom Hook パターン

カスタム Hook のドキュメントとディスカバビリティ

落とし穴と対策一覧

いまさら聞けない React ルールオブフックス

エラーハンドリング: useSafeAsync フック

フックファクトリパターン

まとめ

useMemo徹底ガイド──Reactアプリの再計算コストを劇的に減らす最適化テクニック

useMemoとは何か

基本シグネチャ

useMemoが効く典型シナリオ

1. データ変換・重い計算

2. フィルタ・ソート・検索

3. JSX生成コスト削減

useCallbackとの違い

実践シナリオ別コード例

例1：検索フィルタリング

例2：高コスト画像処理

例3：ソート済みキャッシュ

依存配列設計のコツ

パフォーマンス測定と検証

Profiler API

console.time計測

よくある落とし穴

useMemoを使わない方がいい場合

useMemo と Suspense / Concurrent Features

まとめ

ReactのuseCallback徹底ガイド──依存配列・再レンダリング制御・パフォーマンス最適化の基本と応用

はじめに

useCallbackとは？

基本シグネチャと戻り値

依存配列の正しい書き方

useCallbackとuseMemoの違い

子コンポーネントの最適化例

使わないほうがいいケース

複数フックとの連携パターン

useCallback + useEffect

useCallback + useMemo

コールバック関数のテスト

パフォーマンス計測とベンチマーク

よくある誤解とQ&A

まとめ

Reactエフェクトのライフサイクル完全ガイド──useEffectがいつ動く？依存関係・クリーンアップ・タイミングを徹底解説

はじめに

Reactエフェクトの基本概念

ライフサイクルフロー全体像

マウント後の初回実行

依存配列による再実行制御

クリーンアップ関数の重要性

useLayoutEffectとuseEffectの違い

副次的レンダーとスケジューリング

パフォーマンス最適化パターン

よくある落とし穴と対策

実践例：データフェッチ×キャンセルパターン

まとめ

`useMemo` と Suspense / Concurrent Features

`useLayoutEffect`と`useEffect`の違い