ReactのuseReducerで複雑な状態管理を簡単に！初心者向け徹底解説

Reactでアプリケーションを開発する際、状態管理は避けて通れない重要な要素です。特に、状態が複雑になると、単純なuseStateでは管理が難しくなる場合があります。そこで登場するのが、Reactの標準フックであるuseReducerです。このフックを利用することで、複雑な状態遷移を簡潔かつ明確に記述することが可能になります。本記事では、useReducerの基本概念から実践的な活用方法、応用例までを詳しく解説し、React開発者がより効率的に複雑な状態を扱えるようサポートします。

useReducerとは何か

useReducerは、Reactで状態管理を行うためのフックで、現在の状態とアクションに基づいて次の状態を計算する「Reducer関数」を用います。Reduxで使われる考え方と似ており、特に複雑な状態遷移や一連の関連した状態を扱う場合に有効です。

useStateとの違い

useStateはシンプルな状態管理に適しており、ボタンのクリックや入力フォームの値の変更など、単純な状態変化を簡単に扱えます。一方、useReducerは、以下の場合に適しています：

状態が複雑で、複数のアクションによって異なる方法で状態が更新される場合。
状態遷移ロジックを一箇所にまとめて管理したい場合。
useStateでは複雑すぎる処理を簡潔に記述したい場合。

Reducer関数とは

Reducer関数は、以下のような形で状態を更新するロジックを記述します：

const reducer = (state, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    case 'DECREMENT':
      return { count: state.count - 1 };
    default:
      throw new Error('Unknown action type');
  }
};

この関数は、現在の状態（state）とアクション（action）を受け取り、新しい状態を返します。useReducerフックは、このReducer関数を活用して状態を管理します。

useReducerの構文と基本的な使い方

useReducerを使うには、まずReducer関数を定義し、Reactコンポーネント内でuseReducerフックを呼び出します。以下に基本的な構文とサンプルコードを紹介します。

useReducerの構文

useReducerは次のようなシグネチャを持ちます：

const [state, dispatch] = useReducer(reducer, initialState);

reducer: 現在の状態とアクションを受け取り、新しい状態を返す関数。
initialState: 初期状態を表す値。
state: 現在の状態。
dispatch: Reducer関数を呼び出して状態を更新するための関数。

基本的な例

次に、カウンターアプリを例にuseReducerを使ったコードを示します：

import React, { useReducer } from 'react';

// Reducer関数
const reducer = (state, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    case 'DECREMENT':
      return { count: state.count - 1 };
    case 'RESET':
      return { count: 0 };
    default:
      throw new Error('Unknown action type');
  }
};

// 初期状態
const initialState = { count: 0 };

const Counter = () => {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <div>
      <h1>Count: {state.count}</h1>
      <button onClick={() => dispatch({ type: 'INCREMENT' })}>Increment</button>
      <button onClick={() => dispatch({ type: 'DECREMENT' })}>Decrement</button>
      <button onClick={() => dispatch({ type: 'RESET' })}>Reset</button>
    </div>
  );
};

export default Counter;

コードの説明

Reducer関数: 状態遷移のロジックを定義します。action.typeに基づき、新しい状態を返します。
initialState: アプリケーションの初期状態を設定します。
useReducerフック: stateは現在の状態を保持し、dispatchでアクションをReducerに渡します。
イベントハンドラー: ボタンのクリックイベントでdispatchを呼び出し、対応するアクションをReducerに渡して状態を更新します。

このようにuseReducerを活用すれば、シンプルで明確に状態遷移を管理することが可能です。

状態遷移のパターン設計の基本

useReducerを活用して状態管理を行う際、効果的なパターン設計を行うことが重要です。これにより、状態遷移が明確になり、コードの保守性や拡張性が向上します。以下では、状態遷移の設計プロセスと基本的なパターンを解説します。

1. 状態の定義

まず、アプリケーションの状態を明確に定義します。状態はシンプルで分かりやすく設計し、冗長な状態や不要なネストを避けることが重要です。

例：

const initialState = {
  isLoading: false,
  error: null,
  data: null,
};

2. アクションの設計

状態をどのように変更するかを示すアクションを設計します。アクションは一貫性のある命名規則を使用し、明確に目的を伝えるものにしましょう。

例：

const actions = {
  FETCH_START: 'FETCH_START',
  FETCH_SUCCESS: 'FETCH_SUCCESS',
  FETCH_FAILURE: 'FETCH_FAILURE',
};

3. Reducer関数の設計

Reducer関数を作成し、状態遷移ロジックを定義します。この際、状態がどのように遷移するのかを視覚化（ステートマシンの図など）しておくと便利です。

例：

const reducer = (state, action) => {
  switch (action.type) {
    case actions.FETCH_START:
      return { ...state, isLoading: true, error: null };
    case actions.FETCH_SUCCESS:
      return { ...state, isLoading: false, data: action.payload };
    case actions.FETCH_FAILURE:
      return { ...state, isLoading: false, error: action.payload };
    default:
      throw new Error('Unknown action type');
  }
};

4. 状態遷移パターンの選択

以下のようなパターンを活用して設計します：

リクエスト・レスポンスパターン

非同期処理（例：API呼び出し）に適したパターンです。上記の例はこのパターンに基づいています。

ステートマシンパターン

状態遷移をステートマシンのように扱い、状態が明確な遷移パスに基づいて変化するよう設計します。

例：

const reducer = (state, action) => {
  switch (state.status) {
    case 'idle':
      if (action.type === 'FETCH_START') {
        return { status: 'loading', data: null, error: null };
      }
      break;
    case 'loading':
      if (action.type === 'FETCH_SUCCESS') {
        return { status: 'success', data: action.payload, error: null };
      }
      if (action.type === 'FETCH_FAILURE') {
        return { status: 'error', data: null, error: action.payload };
      }
      break;
    default:
      throw new Error('Invalid state transition');
  }
};

5. 状態遷移のテスト

設計した状態遷移パターンが正しく動作することを確認するためにテストを行います。特に、異常系の遷移パターンや未定義のアクションに対する挙動を確認することが重要です。

設計のポイント

状態をできるだけ分かりやすくシンプルに保つ。
アクションタイプを定数化し、間違いを防ぐ。
Reducer内で副作用（API呼び出しなど）を避ける。

これらを活用することで、useReducerを用いた状態管理がより効果的になります。

コンテキストとuseReducerの組み合わせ

useReducerは単一コンポーネントでの状態管理に便利ですが、大規模なアプリケーションでは複数のコンポーネント間で状態を共有する必要があります。その際に有効なのが、React Contextと組み合わせた状態管理です。この方法により、アプリケーション全体で効率的にグローバル状態を管理できます。

React Contextとは

React Contextは、プロパティの「バケツリレー」問題を解決するための機能です。グローバルな状態やデータをコンポーネントツリー全体で簡単に共有できます。

useReducerとContextの組み合わせ方

useReducerをReact Contextと組み合わせるには、以下の手順を踏みます。

1. 状態管理ロジックの作成

useReducerを利用して状態管理のロジックを作成します。

const reducer = (state, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    case 'DECREMENT':
      return { count: state.count - 1 };
    default:
      throw new Error('Unknown action type');
  }
};

const initialState = { count: 0 };

2. Contextの作成

React Contextを作成します。複数のContextを作成して、状態とdispatch関数を分離することも可能です。

import { createContext } from 'react';

export const StateContext = createContext();
export const DispatchContext = createContext();

3. プロバイダーの実装

Contextプロバイダーを定義し、useReducerで生成されたstateとdispatchを提供します。

import React, { useReducer } from 'react';

const AppProvider = ({ children }) => {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <StateContext.Provider value={state}>
      <DispatchContext.Provider value={dispatch}>
        {children}
      </DispatchContext.Provider>
    </StateContext.Provider>
  );
};

export default AppProvider;

4. コンポーネントでの利用

Contextを利用して、必要なコンポーネントで状態やdispatch関数を取得します。

import React, { useContext } from 'react';
import { StateContext, DispatchContext } from './context';

const Counter = () => {
  const state = useContext(StateContext);
  const dispatch = useContext(DispatchContext);

  return (
    <div>
      <h1>Count: {state.count}</h1>
      <button onClick={() => dispatch({ type: 'INCREMENT' })}>Increment</button>
      <button onClick={() => dispatch({ type: 'DECREMENT' })}>Decrement</button>
    </div>
  );
};

export default Counter;

設計のポイント

分離されたContext: 状態とdispatchを分離することで、再レンダリングを最小限に抑えられます。
モジュール化: ContextとReducerロジックを別ファイルに分けることで、コードの見通しが良くなります。
型安全性: TypeScriptを利用して、Contextやアクションの型を定義すると、より安全に状態管理を行えます。

活用例

この手法は、ユーザー認証、テーマの切り替え、設定管理など、アプリケーション全体で共有する必要のあるデータ管理に最適です。useReducerとContextを組み合わせれば、Reactアプリケーションをより効率的に構築できます。

実践的な例: 複雑なフォーム管理

フォームはReactアプリケーションでよく使われる機能ですが、複数の入力フィールドやバリデーションを伴うフォームは複雑になりがちです。useReducerを利用することで、フォームの状態管理とロジックを整理し、簡潔に実装できます。

複数フィールドを持つフォームの課題

入力フィールドごとに状態を個別に管理する場合、コードが冗長になりやすい。
バリデーションやエラーメッセージの管理が煩雑になる。
状態を一括でリセットしたい場合、個別管理では手間がかかる。

useReducerを使うことで、これらの問題をシンプルに解決できます。

フォーム管理の設計

初期状態: フォームの各フィールドとその値をオブジェクトで定義します。
Reducer関数: 各アクションに応じて状態を更新します。
dispatch関数: イベントハンドラーで使用し、状態を変更します。

フォームの実装例

以下は、名前とメールアドレスを入力するフォームの例です。

import React, { useReducer } from 'react';

// Reducer関数
const reducer = (state, action) => {
  switch (action.type) {
    case 'UPDATE_FIELD':
      return {
        ...state,
        [action.field]: action.value,
      };
    case 'RESET':
      return initialState;
    default:
      throw new Error('Unknown action type');
  }
};

// 初期状態
const initialState = {
  name: '',
  email: '',
};

const FormExample = () => {
  const [state, dispatch] = useReducer(reducer, initialState);

  // フィールド更新ハンドラー
  const handleChange = (e) => {
    dispatch({ type: 'UPDATE_FIELD', field: e.target.name, value: e.target.value });
  };

  // フォーム送信ハンドラー
  const handleSubmit = (e) => {
    e.preventDefault();
    console.log('Form Data:', state);
    dispatch({ type: 'RESET' });
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>
          Name:
          <input
            type="text"
            name="name"
            value={state.name}
            onChange={handleChange}
          />
        </label>
      </div>
      <div>
        <label>
          Email:
          <input
            type="email"
            name="email"
            value={state.email}
            onChange={handleChange}
          />
        </label>
      </div>
      <button type="submit">Submit</button>
    </form>
  );
};

export default FormExample;

コードの解説

Reducer関数

UPDATE_FIELD: 指定されたフィールドの値を更新します。
RESET: フォームの状態を初期化します。

handleChangeハンドラー
入力フィールドの変更を検知し、dispatchを使って対応するフィールドを更新します。
handleSubmitハンドラー
フォーム送信時に状態をコンソールに出力し、フォームをリセットします。

バリデーションの追加

Reducer関数を拡張することで、簡単にバリデーションロジックを追加できます。

case 'VALIDATE_FIELD':
  return {
    ...state,
    errors: {
      ...state.errors,
      [action.field]: action.value ? '' : `${action.field} is required`,
    },
  };

設計のポイント

状態を1箇所で管理することで、コードの整理が容易になる。
アクションタイプを定数化し、複数のアクションを扱いやすくする。
バリデーションやエラーメッセージの管理もReducerで統一することで保守性が向上する。

このように、useReducerを活用することで、複雑なフォーム管理を効率的に実現できます。

状態管理におけるベストプラクティス

useReducerを用いた状態管理は強力なツールですが、効率的かつ保守しやすいコードを書くためには、いくつかのベストプラクティスを押さえておく必要があります。以下では、useReducerを使う際の推奨事項と、よくある間違いを回避する方法を解説します。

1. 状態の設計をシンプルに保つ

複雑な状態を1つのReducerで管理しようとすると、コードが肥大化し、保守が難しくなります。状態はできるだけシンプルに設計し、必要であれば複数のReducerに分割することを検討してください。

例: シンプルな状態設計

const initialState = {
  user: null,
  isLoading: false,
  error: null,
};

2. アクションタイプを定数として定義

アクションタイプは定数化しておくと、タイプミスを防ぎ、コードの可読性が向上します。

例:

const actionTypes = {
  FETCH_START: 'FETCH_START',
  FETCH_SUCCESS: 'FETCH_SUCCESS',
  FETCH_FAILURE: 'FETCH_FAILURE',
};

3. アクションのペイロードを活用する

アクションには必要なデータ（ペイロード）を含めることで、Reducer関数を汎用的に設計できます。

例:

dispatch({ type: actionTypes.FETCH_SUCCESS, payload: data });

Reducerでの処理:

case actionTypes.FETCH_SUCCESS:
  return { ...state, isLoading: false, data: action.payload };

4. 副作用はReducer外で処理

API呼び出しやローカルストレージの操作などの副作用は、Reducerではなく、useEffectやカスタムフックで処理します。これにより、Reducerを純粋な関数として保つことができます。

例:

useEffect(() => {
  dispatch({ type: actionTypes.FETCH_START });
  fetchData()
    .then(data => dispatch({ type: actionTypes.FETCH_SUCCESS, payload: data }))
    .catch(error => dispatch({ type: actionTypes.FETCH_FAILURE, payload: error }));
}, []);

5. エラーハンドリングの設計

エラーハンドリングの状態やアクションを明確に設計することで、ユーザーに適切なフィードバックを提供できます。

例:

const initialState = {
  data: null,
  isLoading: false,
  error: null,
};

const reducer = (state, action) => {
  switch (action.type) {
    case actionTypes.FETCH_START:
      return { ...state, isLoading: true, error: null };
    case actionTypes.FETCH_SUCCESS:
      return { ...state, isLoading: false, data: action.payload };
    case actionTypes.FETCH_FAILURE:
      return { ...state, isLoading: false, error: action.payload };
    default:
      throw new Error('Unknown action type');
  }
};

6. 再利用可能なコードを意識する

よく使うReducerロジックやカスタムフックは再利用可能な形で設計します。これにより、異なるコンポーネントで同じロジックを再利用できます。

例: カスタムフック

const useFetchReducer = (initialState) => {
  return useReducer((state, action) => {
    switch (action.type) {
      case 'FETCH_START':
        return { ...state, isLoading: true, error: null };
      case 'FETCH_SUCCESS':
        return { ...state, isLoading: false, data: action.payload };
      case 'FETCH_FAILURE':
        return { ...state, isLoading: false, error: action.payload };
      default:
        throw new Error('Unknown action type');
    }
  }, initialState);
};

7. 状態遷移のテストを行う

Reducer関数は純粋な関数であるため、単体テストを行うのが容易です。すべてのアクションタイプについて、期待通りに動作するかを確認しましょう。

例: Jestでのテスト

test('should handle FETCH_SUCCESS', () => {
  const initialState = { isLoading: true, data: null, error: null };
  const action = { type: 'FETCH_SUCCESS', payload: { id: 1, name: 'Test' } };
  const newState = reducer(initialState, action);
  expect(newState).toEqual({ isLoading: false, data: action.payload, error: null });
});

まとめ

状態設計をシンプルにし、適切な分割を行う。
副作用をReducerから分離して管理する。
再利用可能なロジックをカスタムフックとして構築する。
テストを通じて信頼性を確保する。

これらのベストプラクティスを守ることで、useReducerを利用した状態管理がスムーズかつ保守性の高いものになります。

useReducerとReduxの違い

Reactで状態管理を行う際、useReducerとReduxはどちらも選択肢として挙がりますが、それぞれに適したユースケースや特徴があります。ここでは、両者の違いを比較し、どのような場面でどちらを選ぶべきかを解説します。

1. 基本的な特徴の違い

特徴	useReducer	Redux
利用範囲	コンポーネント内または小規模な状態管理に最適	アプリ全体のグローバル状態管理に最適
ステート管理	ローカルに状態を保持	グローバルな状態を一元管理
依存関係	Reactのビルトイン	外部ライブラリが必要
ミドルウェアの利用	不可	Redux ThunkやSagaで非同期処理が可能
学習コスト	低め	やや高め

2. アクションと状態管理の設計

useReducer: 状態管理はコンポーネント単位で行われ、dispatch関数を直接呼び出して状態を更新します。アクションは単純で構造化されていない場合が多いです。

例: useReducerのアクション

dispatch({ type: 'INCREMENT' });

Redux: 状態はアプリ全体で共有され、アクションは通常オブジェクトとして定義されます。非同期処理やミドルウェアを組み合わせることで、高度なロジックが可能です。

例: Reduxのアクション

const incrementAction = () => ({ type: 'INCREMENT' });
dispatch(incrementAction());

3. 非同期処理の対応

useReducer: 非同期処理は直接対応しておらず、useEffectと組み合わせて実装する必要があります。

例: useReducerでの非同期処理

useEffect(() => {
  dispatch({ type: 'FETCH_START' });
  fetchData()
    .then(data => dispatch({ type: 'FETCH_SUCCESS', payload: data }))
    .catch(error => dispatch({ type: 'FETCH_FAILURE', payload: error }));
}, []);

Redux: Redux ThunkやRedux Sagaといったミドルウェアを使用して、非同期処理を簡潔に管理できます。

例: Redux Thunkでの非同期処理

const fetchData = () => async (dispatch) => {
  dispatch({ type: 'FETCH_START' });
  try {
    const data = await apiCall();
    dispatch({ type: 'FETCH_SUCCESS', payload: data });
  } catch (error) {
    dispatch({ type: 'FETCH_FAILURE', payload: error });
  }
};

4. スケーラビリティ

useReducer: 小規模なアプリや、状態がローカルに閉じている場合に適しています。大規模なアプリケーションでuseReducerを無理に使用すると、状態管理が分散し、複雑さが増す可能性があります。
Redux: アプリ全体の状態を一元管理するため、特に大規模なアプリケーションで効果を発揮します。ただし、小規模アプリでは過剰なツールになりがちです。

5. ライフサイクルとメンテナンス性

useReducer: Reactに内蔵されているため、依存関係が少なくメンテナンスが簡単です。
Redux: 外部ライブラリであり、バージョンアップや設定の変更に伴うメンテナンスが必要です。ただし、Redux Toolkitを使用することで、最近は設定が大幅に簡素化されています。

6. 適したユースケース

ユースケース	推奨方法
小規模アプリケーション	useReducer
コンポーネント内部での状態管理	useReducer
状態が局所的で複雑な遷移を含む場合	useReducer
大規模アプリケーション	Redux
状態をアプリ全体で共有する必要がある場合	Redux
高度な非同期処理やミドルウェアの利用が必要な場合	Redux

まとめ

useReducerは、React内蔵の軽量な状態管理ツールとして、局所的な状態を扱う場合に適しています。一方、Reduxは、アプリ全体でグローバル状態を共有する必要がある場合や、大規模なアプリケーションでその真価を発揮します。プロジェクトの規模や要件に応じて、適切なツールを選択することが重要です。

演習: タスク管理アプリを作成する

ここでは、useReducerを使用して基本的なタスク管理アプリを構築する手順を解説します。この演習を通じて、useReducerの実践的な使い方を理解し、複雑な状態管理を簡潔に実装するスキルを習得しましょう。

アプリの仕様

ユーザーはタスクを追加できる。
タスクを完了済みにしたり削除したりできる。
完了したタスクは表示が切り替わる。

ステップ 1: 初期状態とReducer関数の作成

まず、アプリの状態を定義し、Reducer関数で状態遷移を管理します。

const initialState = {
  tasks: [],
};

const reducer = (state, action) => {
  switch (action.type) {
    case 'ADD_TASK':
      return {
        ...state,
        tasks: [...state.tasks, { id: Date.now(), text: action.payload, completed: false }],
      };
    case 'TOGGLE_TASK':
      return {
        ...state,
        tasks: state.tasks.map(task =>
          task.id === action.payload ? { ...task, completed: !task.completed } : task
        ),
      };
    case 'DELETE_TASK':
      return {
        ...state,
        tasks: state.tasks.filter(task => task.id !== action.payload),
      };
    default:
      throw new Error('Unknown action type');
  }
};

ステップ 2: コンポーネントの構造

タスクの表示と操作を管理するReactコンポーネントを作成します。

import React, { useReducer, useState } from 'react';

const TaskApp = () => {
  const [state, dispatch] = useReducer(reducer, initialState);
  const [taskText, setTaskText] = useState('');

  const handleAddTask = () => {
    if (taskText.trim() === '') return;
    dispatch({ type: 'ADD_TASK', payload: taskText });
    setTaskText('');
  };

  return (
    <div>
      <h1>Task Manager</h1>
      <div>
        <input
          type="text"
          value={taskText}
          onChange={(e) => setTaskText(e.target.value)}
          placeholder="Add a new task"
        />
        <button onClick={handleAddTask}>Add Task</button>
      </div>
      <TaskList tasks={state.tasks} dispatch={dispatch} />
    </div>
  );
};

const TaskList = ({ tasks, dispatch }) => {
  return (
    <ul>
      {tasks.map(task => (
        <li key={task.id}>
          <span
            style={{
              textDecoration: task.completed ? 'line-through' : 'none',
            }}
            onClick={() => dispatch({ type: 'TOGGLE_TASK', payload: task.id })}
          >
            {task.text}
          </span>
          <button onClick={() => dispatch({ type: 'DELETE_TASK', payload: task.id })}>
            Delete
          </button>
        </li>
      ))}
    </ul>
  );
};

export default TaskApp;

ステップ 3: 実装のポイント

タスク追加
ADD_TASKアクションで、新しいタスクを状態に追加します。タスクには一意のidを生成し、textとcompletedフラグを設定します。
タスクの完了切り替え
TOGGLE_TASKアクションで、指定したタスクのcompletedフラグを反転させます。map関数を使用して状態を更新します。
タスク削除
DELETE_TASKアクションで、指定したタスクを削除します。filter関数を使用してタスクを絞り込みます。

ステップ 4: スタイリングと拡張

スタイリング: CSSを追加してタスクリストを見やすくします。
機能拡張: タスクの編集機能やフィルタリング機能（完了済みタスクの表示切り替え）を追加することで、さらに高度な状態管理を練習できます。

まとめ

この演習では、useReducerを活用して基本的なタスク管理アプリを構築しました。このプロジェクトを通じて、useReducerの状態遷移の管理方法や、リアクティブなアクションの実装方法を学ぶことができます。次のステップとして、Contextと組み合わせたグローバル状態管理や、非同期処理の導入に挑戦してみましょう！

まとめ

本記事では、ReactのuseReducerを活用した複雑な状態管理の方法について解説しました。useReducerは、単純な状態管理から複雑なロジックを含むアプリケーションまで対応可能な便利なフックです。その構文や使い方を基本から実践的な例まで紹介し、状態遷移の設計やContextとの組み合わせ、Reduxとの比較など、多角的にその有用性を示しました。

特に、タスク管理アプリの演習を通じて、useReducerが複雑な状態管理をどれほど簡潔に整理できるかをご理解いただけたと思います。useReducerを習得することで、Reactアプリケーションの開発効率を大幅に向上させることができます。ぜひ、日々のプロジェクトで活用してみてください！

ReactのuseReducerで複雑な状態管理を簡単に！初心者向け徹底解説

useReducerとは何か

useStateとの違い

Reducer関数とは

useReducerの構文と基本的な使い方

useReducerの構文

基本的な例

コードの説明

状態遷移のパターン設計の基本

1. 状態の定義

2. アクションの設計

3. Reducer関数の設計

4. 状態遷移パターンの選択

リクエスト・レスポンスパターン

ステートマシンパターン

5. 状態遷移のテスト

設計のポイント

コンテキストとuseReducerの組み合わせ

React Contextとは

useReducerとContextの組み合わせ方

1. 状態管理ロジックの作成

2. Contextの作成

3. プロバイダーの実装

4. コンポーネントでの利用

設計のポイント

活用例

実践的な例: 複雑なフォーム管理

複数フィールドを持つフォームの課題

フォーム管理の設計

フォームの実装例

コードの解説

バリデーションの追加

設計のポイント

状態管理におけるベストプラクティス

1. 状態の設計をシンプルに保つ

2. アクションタイプを定数として定義

3. アクションのペイロードを活用する

4. 副作用はReducer外で処理

5. エラーハンドリングの設計

6. 再利用可能なコードを意識する

7. 状態遷移のテストを行う

まとめ

useReducerとReduxの違い

1. 基本的な特徴の違い

2. アクションと状態管理の設計

3. 非同期処理の対応

4. スケーラビリティ

5. ライフサイクルとメンテナンス性

6. 適したユースケース

まとめ

演習: タスク管理アプリを作成する

アプリの仕様

ステップ 1: 初期状態とReducer関数の作成

ステップ 2: コンポーネントの構造

ステップ 3: 実装のポイント

ステップ 4: スタイリングと拡張

まとめ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル