DokumentePreiseBlog
Kontaktieren Sie uns
AnmeldenKOSTENLOS anmelden
Back to Tech Articles

再利用可能で回復力のあるReactカスタムフックの作成

Sept. 01, 2025
# Misc

Lukas Schneider

DevOps Engineer · Leapcell

Dieser Beitrag ist auch in English, 한국어 und Deutsch verfügbar
Cover of "再利用可能で回復力のあるReactカスタムフックの作成"

はじめに

進化し続けるモダンなWeb開発の状況において、Reactは動的なユーザーインターフェースを構築するための主要なライブラリとしての地位を確立しました。その成功に大きく貢献した要因の1つは、コンポーネントベースのアーキテクチャの採用であり、より最近ではHooksの導入です。Hooksは、関数コンポーネントの状態と副作用の管理方法に根本的な変化をもたらし、よりクリーンで、読みやすく、よりコンポーザブルなコードにつながりました。しかし、Hooksを使用することと、高品質で再利用可能なカスタムHooksを作成することは別問題です。この区別は、スケーラブルで保守性が高く、堅牢なReactアプリケーションを構築する上で非常に重要です。慎重な設計なしでは、カスタムHooksはすぐに、開発を助けるどころか妨げる、密結合で脆いロジックの断片に陥ってしまう可能性があります。この記事では、アプリケーションを真に強化するカスタムHooksを作成するための効果的なデザインパターンとベストプラクティスを探り、コードベースをより効率的で管理しやすくします。

堅牢なカスタムHooksのためのコアコンセプト

デザインパターンに飛び込む前に、効果的なカスタムHooksの作成を支えるコアコンセプトについての共通理解を確立しましょう。これらの用語は、議論全体で再確認されます。

カスタムHook: 名前に「use」で始まり、他のHooksを呼び出すことができるJavaScript関数。カスタムHooksは、ロジックをコンポーネント間で共有するために主に使用されます。UIではありません。

再利用性: カスタムHookが、大幅な変更なしに複数の多様なコンポーネントやアプリケーションに組み込まれる能力。再利用可能なHookは、さまざまなコンテキストで一般的な懸念事項に対処するのに十分汎用的です。

保守性: 時間の経過とともに、カスタムHookを理解、変更、デバッグする容易さ。適切に設計されたHookは自己完結型であり、明確な責任を持つため、変更時にバグを発生させる可能性が低くなります。

関心の分離: 大きなシステムを、それぞれが特定の関心事を扱う、明確で重複のないセクションに分割する原則。カスタムHooksの場合、これは各Hookが理想的には1つのことをうまく行うべきであることを意味します。

API設計: カスタムHookが、引数、返り値、および暗黙的な動作を含む、コンシューミングコンポーネントに公開するインターフェース。良いAPIは直感的で予測可能であり、認知的負荷を最小限に抑えます。

テスト: さまざまな条件下でカスタムHookが期待どおりに機能することを検証するプロセス。高品質のHookは、UIからロジックを分離しているため、本質的にテスト可能です。

再利用可能で保守性の高いカスタムHooksの設計

高品質で再利用可能なカスタムHooksを作成するには、その設計と実装に思慮深いアプローチが必要です。ここでは、いくつかの主要なパターンと戦略を探ります。

1. 単一責任の原則

良いソフトウェア設計の基盤は、カスタムHooksにも適用されます。各Hookは、単一の、明確に定義された目的を持つべきです。多くのことをやろうとする「ゴッドHooks」の作成は避けてください。

問題: ユーザー認証、プロファイル更新、友達リクエストを処理するuseUserManagement Hook。 解決策: useAuthentication、useUserProfile、useFriendRequestsに分割します。

例:

モーダルの可視性を管理するカスタムHookを考えてみましょう。

// 悪い例：過度に複雑で、UIロジックと状態が混在
function useModal(initialState = false) {
  const [isOpen, setIsOpen] = React.useState(initialState);
  const [modalTitle, setModalTitle] = React.useState(''); // UIの懸念事項

  const openModal = (title) => {
    setIsOpen(true);
    setModalTitle(title);
  };
  const closeModal = () => setIsOpen(false);

  return { isOpen, openModal, closeModal, modalTitle }; // UI固有の状態を公開
}

// 良い例：可視性の切り替えにのみ焦点を当てる
function useToggle(initialState = false) {
  const [isVisible, setIsVisible] = React.useState(initialState);

  const show = () => setIsVisible(true);
  const hide = () => setIsVisible(false);
  const toggle = () => setIsVisible(prev => !prev);

  return { isVisible, show, hide, toggle };
}

// 良い例との連携：
function MyComponent() {
  const { isVisible, show, hide } = useToggle();

  return (
    <div>
      <button onClick={show}>Open Modal</button>
      {isVisible && (
        <div className="modal">
          <h2>Modal Title</h2> {/* Hookではなくコンポーネントで処理されるタイトル */}
          <p>Modal Content</p>
          <button onClick={hide}>Close</button>
        </div>
      )}
    </div>
  );
}

useToggle Hookは、モーダル、ドロップダウン、ツールチップ、または任意のブール値トグルに適用できるブール値の状態のみを管理するため、はるかに再利用性が高くなります。

2. 明確で直感的なAPI

カスタムHookの入力と出力は、明示的で理解しやすいものであるべきです。Hookがその機能を実行するために必要な引数と、コンシューミングコンポーネントに返すデータや関数について考えてみてください。

引数：

  • 最小限に保ちます。
  • 複数のオプション引数には、しばしばオプションオブジェクトを渡して分割代入を使用します。

返り値：

  • 多くの場合、タプル [state, setState] またはオブジェクト { state, handlers } です。
  • 明瞭さと拡張性のために選択します。タプルは単純な状態マネージャー（useStateなど）に最適ですが、オブジェクトは複数の関連値と関数を返すHookに最適です。

例：非同期データ取得の処理

// 悪いAPI：順序付けされた引数に依存し、拡張性に欠ける
function useFetch(url, options, initialData) { /* ... */ }

// より良いAPI：明瞭さと将来の拡張のためにオプションオブジェクトを使用
function useFetch(url, { initialData = null, immediate = true, cacheKey = null, headers = {} } = {}) {
  const [data, setData] = React.useState(initialData);
  const [loading, setLoading] = React.useState(true);
  const [error, setError] = React.useState(null);

  const fetchData = React.useCallback(async (payload = {}) => {
    setLoading(true);
    setError(null);
    try {
      const response = await fetch(url, { ...options, body: JSON.stringify(payload) });
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const result = await response.json();
      setData(result);
    } catch (err) {
      setError(err);
    } finally {
      setLoading(false);
    }
  }, [url, options]); // メモ化のための依存関係

  React.useEffect(() => {
    if (immediate) {
      fetchData();
    }
  }, [immediate, fetchData]);

  return { data, loading, error, fetchData };
}

// 使用法：
function UserProfile({ userId }) {
  const { data: user, loading, error, fetchData } = useFetch(`/api/users/${userId}`, {
    initialData: { name: '', email: '' },
    immediate: true,
    headers: { 'Authorization': 'Bearer ...' }
  });

  if (loading) return <div>Loading user...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.email}</p>
      <button onClick={() => fetchData()}>Refresh Profile</button>
    </div>
  );
}

オプションオブジェクトにより、useFetch HookのAPIがより説明的になり、既存の統合を壊すことなく新しい設定パラメータを簡単に追加できます。

3. 複雑なロジックと副作用のカプセル化

カスタムHooksは、複雑なロジック、特に副作用（useEffect、useRef、API呼び出し、DOM操作など）を伴うロジックを抽象化するのに理想的です。これにより、コンポーネントはクリーンでレンダリングに集中できます。

例：値のデバウンス

function useDebounce(value, delay) {
  const [debouncedValue, setDebouncedValue] = React.useState(value);

  React.useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]);

  return debouncedValue;
}

// 使用法：
function SearchInput() {
  const [searchTerm, setSearchTerm] = React.useState('');
  const debouncedSearchTerm = useDebounce(searchTerm, 500);

  // デバウンスされた検索用語が変更されたときにのみ実行される効果
  React.useEffect(() => {
    if (debouncedSearchTerm) {
      console.log('Fetching results for:', debouncedSearchTerm);
      // debouncedSearchTermでAPI呼び出しを実行
    }
  }, [debouncedSearchTerm]);

  return (
    <input
      type="text"
      placeholder="Search..."
      value={searchTerm}
      onChange={(e) => setSearchTerm(e.target.value)}
    />
  );
}

ここで、useDebounceは、useStateとuseEffect（クリーンアップを含む）全体を含むデバウンスのロジック全体をカプセル化しており、デバウンスされた値が必要なあらゆるコンテキストで高度に再利用可能になります。

4. 適切なデフォルト値と設定オプションの提供

Hookを、妥当なデフォルト値を引数として提供することで、可能な限りプラグアンドプレイできるように設計します。より多くの制御が必要な場合は、オプションオブジェクトを介したカスタマイズを許可します。

例：useLocalStorage

function useLocalStorage(key, initialValue) {
  const [storedValue, setStoredValue] = React.useState(() => {
    try {
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      console.error(error);
      return initialValue;
    }
  });

  const setValue = (value) => {
    try {
      const valueToStore = value instanceof Function ? value(storedValue) : value;
      setStoredValue(valueToStore);
      window.localStorage.setItem(key, JSON.stringify(valueToStore));
    } catch (error) {
      console.error(error);
    }
  };

  return [storedValue, setValue];
}

// 使用法：
function SettingsPanel() {
  const [theme, setTheme] = useLocalStorage('appTheme', 'light');
  const [notificationsEnabled, setNotificationsEnabled] = useLocalStorage('notifications', true);

  return (
    <div>
      <label>
        Theme:
        <select value={theme} onChange={(e) => setTheme(e.target.value)}>
          <option value="light">Light</option>
          <option value="dark">Dark</option>
        </select>
      </label>
      <label>
        <input
          type="checkbox"
          checked={notificationsEnabled}
          onChange={(e) => setNotificationsEnabled(e.target.checked)}
        />
        Enable Notifications
      </label>
    </div>
  );
}

useLocalStorageは、既存のデータを解析するか、initialValueにフォールバックすることで、すぐに役立つデフォルトを提供し、複雑なセットアップなしで簡単に使用できるようにします。

5. パフォーマンスの考慮（メモ化）

高価な計算を実行したり関数を返したりするカスタムHookの場合、不要な再レンダリングや関数の再作成を防ぐためにuseMemoとuseCallbackを使用します。これは、頻繁に呼び出されたり、複雑な状態を管理したりするHookにとって特に重要です。

例：useCounter（メモ化された関数付き）

function useCounter(initialCount = 0) {
  const [count, setCount] = React.useState(initialCount);

  // incrementとdecrement関数をメモ化するためにuseCallbackを使用
  const increment = React.useCallback(() => {
    setCount(prevCount => prevCount + 1);
  }, []); // 空の依存配列は、これらの関数が一度作成されることを意味します

  const decrement = React.useCallback(() => {
    setCount(prevCount => prevCount - 1);
  }, []);

  const reset = React.useCallback(() => {
    setCount(initialCount);
  }, [initialCount]); // initialCountに依存

  return { count, increment, decrement, reset };
}

// 使用法：
function CounterDisplay() {
  const { count, increment, decrement, reset } = useCounter(10);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
      <button onClick={decrement}>Decrement</button>
      <button onClick={reset}>Reset</button>
    </div>
  );
}

increment、decrement、resetをメモ化することにより、これらの関数はCounterDisplayのすべてのレンダリングで再作成されないため、Propsとして渡される子コンポーネントの不要な再レンダリングを防ぐことができます。

6. 優れたテストカバレッジの提供

高品質のHookは徹底的にテストされます。Hookはロジックを抽象化するため、完全なコンポーネントよりも単独でテストするのが容易な場合が多いです。React Testing Libraryのようなライブラリを使用して、UIから独立してテストします。

useToggle Hookをテストする例（JestとReact Testing LibraryのrenderHookを使用）：

// useToggle.test.js
import { renderHook, act } from '@testing-library/react-hooks';
import { useToggle } from './useToggle'; // useToggleがuseToggle.jsにあると仮定

describe('useToggle', () => {
  it('should initialize with the given initial state', () => {
    const { result } = renderHook(() => useToggle(true));
    expect(result.current.isVisible).toBe(true);
  });

  it('should default to false if no initial state is provided', () => {
    const { result } = renderHook(() => useToggle());
    expect(result.current.isVisible).toBe(false);
  });

  it('should toggle the state', () => {
    const { result } = renderHook(() => useToggle(false));

    act(() => {
      result.current.toggle();
    });
    expect(result.current.isVisible).toBe(true);

    act(() => {
      result.current.toggle();
    });
    expect(result.current.isVisible).toBe(false);
  });

  it('should set the state to true', () => {
    const { result } = renderHook(() => useToggle(false));
    act(() => {
      result.current.show();
    });
    expect(result.current.isVisible).toBe(true);
  });

  it('should set the state to false', () => {
    const { result } = renderHook(() => useToggle(true));
    act(() => {
      result.current.hide();
    });
    expect(result.current.isVisible).toBe(false);
  });
});

このテストスイートは、useToggle Hookのさまざまな動作をカバーし、その信頼性と正確性を保証します。

結論

単一責任、明確なAPI設計、効果的なカプセル化、適切なデフォルト値、パフォーマンス最適化、包括的なテストなどの原則に従うことで、ReactカスタムHookの品質と再利用性を大幅に向上させることができます。これらのデザインパターンは、コードベースが効率的であるだけでなく、長期的にも開発や保守が楽しいものになるように推進します。適切に作成されたカスタムHookは、複雑なロジックを抽象化する強力なツールであり、Reactアプリケーションをエレガントでスケーラブルなシステムに変えます。

Share this article

HackerNews

More Posts from Leapcell

Popular Posts