TypeScriptでのRedux Toolkit状態管理の型定義を徹底解説

TypeScriptは、JavaScriptの強力な型付け機能を提供することで、開発効率とコードの信頼性を向上させます。一方、Redux Toolkitは、従来のReduxの煩雑さを解消し、簡潔かつ効率的な状態管理を可能にするツールです。この二つを組み合わせることで、フロントエンド開発における状態管理の課題を解決し、保守性の高いアプリケーションを構築できます。本記事では、TypeScriptを用いてRedux Toolkitでの状態管理を型安全に実装する方法を詳しく解説します。最適な開発環境の構築から、具体的なコード例まで、包括的に紹介します。

Redux Toolkitの概要

Redux Toolkitは、Reduxの公式ライブラリであり、Reduxをより簡単に扱えるように設計されています。従来のReduxでは、アクションやリデューサーの定義が冗長になりがちですが、Redux Toolkitはその問題を解決するための以下の機能を提供します。

主な特徴

1. createSlice

アクションとリデューサーをまとめて定義する機能です。これにより、冗長なコードを大幅に削減できます。

2. createAsyncThunk

非同期アクションを簡潔に定義するための機能で、APIリクエストの管理を容易にします。

3. configureStore

Reduxストアのセットアップを簡素化するための関数です。ミドルウェアやDevToolsの統合が容易になります。

なぜRedux Toolkitを使うのか

シンプルなAPI：Reduxの基本概念を保ちながら、ボイラープレートコードを削減します。
効率的な開発：非同期処理や複数のSliceの統合が容易です。
型安全：TypeScriptとの親和性が高く、型定義のサポートが充実しています。

このように、Redux ToolkitはReactアプリケーションの状態管理を効率化する強力なツールです。次に、このRedux ToolkitをTypeScriptと組み合わせる準備について解説します。

TypeScriptの導入準備

Redux ToolkitとTypeScriptを併用するには、適切な開発環境を構築することが重要です。以下では、プロジェクトにTypeScriptを導入し、Redux Toolkitを使用するための設定手順を説明します。

プロジェクトのセットアップ

1. TypeScriptと必要な依存パッケージのインストール

まず、Reactアプリケーションを作成し、必要なパッケージをインストールします。

npx create-react-app my-app --template typescript
cd my-app
npm install @reduxjs/toolkit react-redux

--template typescript：TypeScriptテンプレートを使用してReactアプリを作成します。
@reduxjs/toolkitとreact-redux：Redux ToolkitとReact Reduxのライブラリです。

2. tsconfig.jsonの確認と設定

TypeScriptプロジェクトの設定を管理するtsconfig.jsonを確認します。以下は一般的な設定例です。

{
  "compilerOptions": {
    "strict": true,
    "module": "ESNext",
    "target": "ES6",
    "jsx": "react-jsx",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "skipLibCheck": true
  }
}

strictをtrueに設定することで、型安全性を向上させます。
その他のオプションは、ReactとTypeScriptの一般的な設定です。

ディレクトリ構造の準備

Redux Toolkitを効率的に利用するために、以下のようなディレクトリ構造を準備します。

src/
├── app/
│   └── store.ts
├── features/
│   └── example/
│       ├── exampleSlice.ts
│       └── exampleTypes.ts
└── index.tsx

app/store.ts：Reduxストアを設定するファイルです。
features/example/：各Sliceや型定義を管理するフォルダです。

Redux Toolkitの基本設定

以下に、store.tsの基本的な設定例を示します。

import { configureStore } from '@reduxjs/toolkit';

export const store = configureStore({
  reducer: {}, // 後でリデューサーを追加
});

export type RootState = ReturnType<typeof store.getState>;
export type AppDispatch = typeof store.dispatch;

以上の手順で、TypeScriptとRedux Toolkitを使用する準備が整います。次は、具体的なSliceの型定義について解説します。

Sliceの型定義

Redux ToolkitのcreateSliceを使用して、状態管理を簡潔に記述する際に、TypeScriptによる型定義は重要です。これにより、型安全で保守性の高いコードを実現できます。

Sliceの基本構造

以下は、createSliceの基本的な使用例です。

import { createSlice, PayloadAction } from '@reduxjs/toolkit';

interface ExampleState {
  value: number;
}

const initialState: ExampleState = {
  value: 0,
};

const exampleSlice = createSlice({
  name: 'example',
  initialState,
  reducers: {
    increment: (state) => {
      state.value += 1;
    },
    decrement: (state) => {
      state.value -= 1;
    },
    setValue: (state, action: PayloadAction<number>) => {
      state.value = action.payload;
    },
  },
});

export const { increment, decrement, setValue } = exampleSlice.actions;
export default exampleSlice.reducer;

型定義のポイント

1. Stateの型定義

状態を表すExampleState型を作成します。この型に従って初期状態initialStateを定義することで、状態の構造が明確になります。

interface ExampleState {
  value: number;
}

2. PayloadActionの型指定

createSliceのreducers内で使用するPayloadActionには、ペイロードの型を明示的に指定します。例えば、setValueアクションではPayloadAction<number>を指定しています。

型定義の利点

コンパイル時のエラー検出：型のミスマッチがある場合に即座に検出されます。
開発者体験の向上：コード補完が強化され、意図しないエラーを防ぎます。
保守性の向上：型情報により、状態やアクションの構造を一目で把握できます。

Sliceの型定義を活用する

上述の例をディレクトリ構造に適用すると、状態管理がモジュール化され、可読性と保守性が向上します。次は、Redux全体で使用するRootStateと型の設計について解説します。

RootStateと型の設計

Reduxアプリケーションでは、全体の状態を表すRootStateを正しく型定義することが重要です。RootStateの型定義により、アプリケーション全体の状態を統一的に管理し、型安全なコードを書くことが可能になります。

RootStateの概要

RootStateは、Reduxストア内に保持される全てのスライスの状態を表します。これを定義することで、アプリケーション内の状態を簡単に参照できるようになります。

RootStateの型定義

以下の例では、複数のスライスを持つストアを構築し、RootStateを型付けする方法を示します。

import { configureStore } from '@reduxjs/toolkit';
import exampleReducer from '../features/example/exampleSlice';

export const store = configureStore({
  reducer: {
    example: exampleReducer,
  },
});

// RootState型を定義
export type RootState = ReturnType<typeof store.getState>;
export type AppDispatch = typeof store.dispatch;

型定義の活用

1. useSelectorでの型安全な状態取得

React ReduxのuseSelectorフックを利用して状態を取得する際、RootStateを明示的に指定します。

import { useSelector } from 'react-redux';
import { RootState } from '../app/store';

const value = useSelector((state: RootState) => state.example.value);

この方法により、型安全かつ補完機能が有効な状態取得が可能です。

2. スライスごとの状態参照

スライスのリデューサーごとに状態を分割し、それをRootStateに統合することで、状態の分離と統合が明確になります。

3. Dispatchでの型安全なアクション呼び出し

AppDispatch型を定義して、dispatchを型安全に使用します。

import { useDispatch } from 'react-redux';
import { AppDispatch } from '../app/store';
import { increment } from '../features/example/exampleSlice';

const dispatch = useDispatch<AppDispatch>();
dispatch(increment());

設計のポイント

スライスの状態は明確な型を持たせる。
RootStateを利用して、アプリケーション全体の状態を統一的に管理。
useSelectorとuseDispatchを型安全に利用することで、エラーを防止し、開発体験を向上。

次は、アクションとリデューサーに型を適用する方法について詳しく解説します。

ActionとReducerの型付け

Redux Toolkitでは、アクションとリデューサーを効率的に定義できますが、TypeScriptを活用して型を適用することで、より安全で直感的なコードを書くことができます。本項では、アクションとリデューサーの型付け方法を解説します。

アクションの型付け

Redux ToolkitのcreateSliceを使用する場合、アクションは自動的に生成されます。その際、PayloadActionを活用してアクションのペイロードに型を指定することが重要です。

以下の例では、PayloadActionを使用してアクションのペイロードに型を適用しています。

import { createSlice, PayloadAction } from '@reduxjs/toolkit';

interface ExampleState {
  value: number;
}

const initialState: ExampleState = {
  value: 0,
};

const exampleSlice = createSlice({
  name: 'example',
  initialState,
  reducers: {
    increment: (state) => {
      state.value += 1;
    },
    decrement: (state) => {
      state.value -= 1;
    },
    setValue: (state, action: PayloadAction<number>) => {
      state.value = action.payload;
    },
  },
});

export const { increment, decrement, setValue } = exampleSlice.actions;
export default exampleSlice.reducer;

ポイント

型指定が不要なアクション：incrementやdecrementのように、ペイロードを必要としない場合は型指定不要です。
型指定が必要なアクション：setValueのように、ペイロードを必要とするアクションではPayloadAction<T>を使用して型を指定します。

Reducerの型付け

リデューサーは、状態を更新するロジックを保持します。createSliceを使用する場合、リデューサーはinitialStateの型と一致している必要があります。

const exampleSlice = createSlice({
  name: 'example',
  initialState,
  reducers: {
    increment: (state) => {
      state.value += 1; // TypeScriptが自動的に型チェックを行う
    },
    setValue: (state, action: PayloadAction<number>) => {
      state.value = action.payload; // ペイロードが数値であることが保証される
    },
  },
});

TypeScriptはinitialStateの型に基づいてstateの型を推論します。そのため、リデューサー内での型チェックが不要となり、エラーを未然に防ぐことができます。

型の再利用

複数のアクションやリデューサーで同じペイロード型を使用する場合、型を再利用することでコードを簡潔に保てます。

type ValuePayload = number;

const exampleSlice = createSlice({
  name: 'example',
  initialState,
  reducers: {
    setValue: (state, action: PayloadAction<ValuePayload>) => {
      state.value = action.payload;
    },
  },
});

型付けの利点

エラー防止：ペイロード型が厳密にチェックされるため、間違ったデータが渡されることを防げます。
コード補完：型情報により、IDEでの補完が有効になります。
保守性向上：アクションとリデューサーの型が明示されるため、後からコードを見直す際にも理解しやすくなります。

次は、Reduxストア全体に型定義を適用する方法について解説します。

Redux Storeの型定義

Redux ToolkitでReduxストアを構築する際、適切な型定義を行うことで、アプリケーション全体の状態管理が型安全に行えます。本項では、Reduxストアの設定と型定義について詳しく解説します。

Reduxストアの基本設定

Redux ToolkitのconfigureStoreを使用してストアを作成します。以下の例は、シンプルなストアの設定例です。

import { configureStore } from '@reduxjs/toolkit';
import exampleReducer from '../features/example/exampleSlice';

export const store = configureStore({
  reducer: {
    example: exampleReducer,
  },
});

ここでは、スライス（exampleReducer）をリデューサーとしてストアに統合しています。

ストアの型定義

Redux Toolkitでは、ストアに自動的に型が推論されますが、RootStateとAppDispatchを定義して型安全に利用するのがベストプラクティスです。

RootState型

ストア全体の状態を表す型です。

export type RootState = ReturnType<typeof store.getState>;

この型はstore.getState()の戻り値の型を基に生成され、アプリケーションの全ての状態を統合した型となります。

AppDispatch型

dispatch関数の型を定義します。

export type AppDispatch = typeof store.dispatch;

この型を利用することで、アクションをdispatchする際に型安全性が保証されます。

型定義の活用例

useSelectorでのRootState型の利用

React ReduxのuseSelectorフックで状態を取得する際、RootState型を使用します。

import { useSelector } from 'react-redux';
import { RootState } from '../app/store';

const value = useSelector((state: RootState) => state.example.value);

これにより、IDEでの型補完が有効になり、状態のアクセスが直感的になります。

useDispatchでのAppDispatch型の利用

React ReduxのuseDispatchフックを型安全に使用するには、AppDispatchを明示的に指定します。

import { useDispatch } from 'react-redux';
import { AppDispatch } from '../app/store';
import { increment } from '../features/example/exampleSlice';

const dispatch = useDispatch<AppDispatch>();
dispatch(increment());

これにより、無効なアクションのdispatchを防ぐことができます。

ストア設定時のミドルウェア

configureStoreを使用すると、デフォルトでredux-thunkがミドルウェアに含まれます。他のミドルウェアを追加する場合も型安全に設定可能です。

import { configureStore } from '@reduxjs/toolkit';
import logger from 'redux-logger';

export const store = configureStore({
  reducer: {
    example: exampleReducer,
  },
  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(logger),
});

型定義の利点

型安全な開発：状態やアクションに関するエラーをコンパイル時に検出。
開発体験の向上：IDEの補完機能が強化され、効率的にコードを記述可能。
保守性向上：状態管理の構造が明確になり、大規模なアプリケーションでも柔軟に対応可能。

次は、非同期処理（createAsyncThunk）における型定義の方法を解説します。

非同期処理の型定義

Redux ToolkitのcreateAsyncThunkを使用すると、非同期処理（例：APIリクエスト）を簡潔に記述できます。これにTypeScriptを組み合わせることで、非同期処理を型安全に管理できます。本項では、非同期アクションとその型定義について解説します。

createAsyncThunkの基本構造

createAsyncThunkは、非同期アクションを定義するためのRedux Toolkitの機能です。以下の例は、APIからデータを取得する非同期アクションの基本形です。

import { createAsyncThunk } from '@reduxjs/toolkit';

interface User {
  id: number;
  name: string;
}

// 非同期アクションの作成
export const fetchUsers = createAsyncThunk<User[]>(
  'users/fetch',
  async () => {
    const response = await fetch('https://api.example.com/users');
    const data = await response.json();
    return data as User[];
  }
);

createAsyncThunkの型定義

非同期アクションでは以下の型を指定できます。

戻り値の型（上記例ではUser[]）
ペイロードの型（アクションの引数）
ThunkAPIの型（省略可能）

例：ペイロード型を指定する場合

export const fetchUserById = createAsyncThunk<User, number>(
  'users/fetchById',
  async (userId: number) => {
    const response = await fetch(`https://api.example.com/users/${userId}`);
    const data = await response.json();
    return data as User;
  }
);

第1引数：成功時の戻り値の型（User）
第2引数：引数ペイロードの型（number）

非同期アクションのSlice統合

createAsyncThunkで作成したアクションをcreateSliceに統合します。これにより、リクエストの状態（pending、fulfilled、rejected）を管理できます。

import { createSlice } from '@reduxjs/toolkit';
import { fetchUsers } from './userThunks';

interface UserState {
  users: User[];
  loading: boolean;
  error: string | null;
}

const initialState: UserState = {
  users: [],
  loading: false,
  error: null,
};

const userSlice = createSlice({
  name: 'users',
  initialState,
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchUsers.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(fetchUsers.fulfilled, (state, action) => {
        state.loading = false;
        state.users = action.payload;
      })
      .addCase(fetchUsers.rejected, (state, action) => {
        state.loading = false;
        state.error = action.error.message || 'Failed to fetch users';
      });
  },
});

export default userSlice.reducer;

型の利点

非同期データの安全性：戻り値やペイロードが明確に型付けされ、エラーを防止。
開発効率の向上：補完機能が効率的に動作し、コードの見通しが良くなる。
エラーハンドリングの強化：エラーの型付けにより、予期しないエラーを適切に処理可能。

応用例：カスタムThunkAPIの利用

カスタムのThunkAPIを使用して、ユーザー認証情報やAPIトークンを含む非同期処理を実装できます。

export const fetchSecureData = createAsyncThunk<
  Data,          // 戻り値の型
  void,          // ペイロードの型
  { rejectValue: string } // ThunkAPIの型
>(
  'secureData/fetch',
  async (_, { rejectWithValue }) => {
    try {
      const response = await fetch('https://api.example.com/secure-data');
      if (!response.ok) {
        return rejectWithValue('Unauthorized access');
      }
      const data = await response.json();
      return data as Data;
    } catch (error) {
      return rejectWithValue('Failed to fetch data');
    }
  }
);

次は、TypeScriptを用いた実践例で、Redux Toolkitと型定義を活用する具体的なアプリケーション構築について解説します。

TypeScriptでの実践例

TypeScriptとRedux Toolkitを活用して、型安全な状態管理を実装する具体的なアプリケーション例を紹介します。本例では、ユーザー情報の取得と管理を行う簡単なReactアプリケーションを構築します。

アプリケーションの概要

目的：APIからユーザー情報を取得し、状態管理を行う。
技術スタック：React, Redux Toolkit, TypeScript。
機能：ユーザーリストの取得、ローディング状態の表示、エラーハンドリング。

プロジェクト構成

src/
├── app/
│   └── store.ts
├── features/
│   └── users/
│       ├── userSlice.ts
│       ├── userThunks.ts
│       └── userTypes.ts
└── components/
    └── UserList.tsx

ユーザー機能の実装

1. 型定義（userTypes.ts）

ユーザー情報の型を定義します。

export interface User {
  id: number;
  name: string;
  email: string;
}

export interface UserState {
  users: User[];
  loading: boolean;
  error: string | null;
}

2. 非同期アクションの定義（userThunks.ts）

import { createAsyncThunk } from '@reduxjs/toolkit';
import { User } from './userTypes';

export const fetchUsers = createAsyncThunk<User[]>(
  'users/fetch',
  async () => {
    const response = await fetch('https://api.example.com/users');
    const data = await response.json();
    return data as User[];
  }
);

3. Sliceの作成（userSlice.ts）

import { createSlice } from '@reduxjs/toolkit';
import { UserState } from './userTypes';
import { fetchUsers } from './userThunks';

const initialState: UserState = {
  users: [],
  loading: false,
  error: null,
};

const userSlice = createSlice({
  name: 'users',
  initialState,
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchUsers.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(fetchUsers.fulfilled, (state, action) => {
        state.loading = false;
        state.users = action.payload;
      })
      .addCase(fetchUsers.rejected, (state, action) => {
        state.loading = false;
        state.error = action.error.message || 'Failed to fetch users';
      });
  },
});

export default userSlice.reducer;

4. ストアの設定（store.ts）

import { configureStore } from '@reduxjs/toolkit';
import userReducer from '../features/users/userSlice';

export const store = configureStore({
  reducer: {
    users: userReducer,
  },
});

export type RootState = ReturnType<typeof store.getState>;
export type AppDispatch = typeof store.dispatch;

ユーザーリストコンポーネント（UserList.tsx）

import React, { useEffect } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { RootState, AppDispatch } from '../app/store';
import { fetchUsers } from '../features/users/userThunks';

const UserList: React.FC = () => {
  const dispatch = useDispatch<AppDispatch>();
  const { users, loading, error } = useSelector((state: RootState) => state.users);

  useEffect(() => {
    dispatch(fetchUsers());
  }, [dispatch]);

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

  return (
    <ul>
      {users.map((user) => (
        <li key={user.id}>
          {user.name} - {user.email}
        </li>
      ))}
    </ul>
  );
};

export default UserList;

アプリケーションの実行

コンポーネントUserListをアプリケーション内にレンダリングすることで、ユーザー情報が表示されます。
非同期処理中は「Loading…」が表示され、エラー時にはエラーメッセージが表示されます。

この実践例の利点

型安全な状態管理：状態、アクション、非同期処理に明確な型を適用。
可読性と保守性の向上：モジュール化された構造とTypeScriptによる型補完。
開発効率の向上：Redux ToolkitとTypeScriptの組み合わせでボイラープレートコードを削減。

次は、本記事の内容を簡潔に振り返り、まとめます。

まとめ

本記事では、TypeScriptを用いたRedux Toolkitによる状態管理の型定義方法を解説しました。Redux Toolkitの基本機能から、Sliceや非同期アクション、RootStateの型定義、実際のアプリケーション例まで、包括的に取り上げました。

TypeScriptを導入することで、状態管理における型安全性が向上し、エラーを未然に防ぎ、開発効率が大幅に向上します。特に、createSliceやcreateAsyncThunkを活用した型定義は、開発者体験を向上させるための重要なポイントです。

今後は、さらに複雑なアプリケーション構築や他のツールとの連携を通じて、この知識を実践的に応用してみてください。Redux ToolkitとTypeScriptの組み合わせは、モダンなReactアプリケーション開発における強力なツールセットとなります。

この記事を書いた人

佐藤健司

実務の現場で詰まりがちなポイントを地図にするITブログ「IT trip」を運営。Windows／Office（Teams・Excel）からSQL、サーバ運用、ガジェットまで、再現性のある手順と“なぜそうなるか”を丁寧に解説します。読んだらすぐ試せること、そして迷った人の次の一歩が見えることを大切にしています。

TypeScriptでのRedux Toolkit状態管理の型定義を徹底解説

Redux Toolkitの概要

主な特徴

1. createSlice

2. createAsyncThunk

3. configureStore

なぜRedux Toolkitを使うのか

TypeScriptの導入準備

プロジェクトのセットアップ

1. TypeScriptと必要な依存パッケージのインストール

2. tsconfig.jsonの確認と設定

ディレクトリ構造の準備

Redux Toolkitの基本設定

Sliceの型定義

Sliceの基本構造

型定義のポイント

1. Stateの型定義

2. PayloadActionの型指定

型定義の利点

Sliceの型定義を活用する

RootStateと型の設計

RootStateの概要

RootStateの型定義

型定義の活用

1. useSelectorでの型安全な状態取得

2. スライスごとの状態参照

3. Dispatchでの型安全なアクション呼び出し

設計のポイント

ActionとReducerの型付け

アクションの型付け

ポイント

Reducerの型付け

型の再利用

型付けの利点

Redux Storeの型定義

Reduxストアの基本設定

ストアの型定義

RootState型

AppDispatch型

型定義の活用例

useSelectorでのRootState型の利用

useDispatchでのAppDispatch型の利用

ストア設定時のミドルウェア

型定義の利点

非同期処理の型定義

createAsyncThunkの基本構造

createAsyncThunkの型定義

非同期アクションのSlice統合

型の利点

応用例：カスタムThunkAPIの利用

TypeScriptでの実践例

アプリケーションの概要

プロジェクト構成

ユーザー機能の実装

1. 型定義（userTypes.ts）

2. 非同期アクションの定義（userThunks.ts）

3. Sliceの作成（userSlice.ts）

4. ストアの設定（store.ts）

ユーザーリストコンポーネント（UserList.tsx）

アプリケーションの実行

この実践例の利点

まとめ

この記事を書いた人

関連記事

コメント

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

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