Summary  
This chapter demonstrates how to define a Redux state slice with initial state and reducer functions using Redux Toolkit’s createSlice, and how to integrate that slice into a centralized store with configureStore for global state management.  

General domain of usage  
Task management applications (to-do lists)


Create the file:

```bash
src/features/tasks/tasksSlice.js
```

Add the initial slice:

```javascript
import { createSlice } from '@reduxjs/toolkit';

const initialState = {
  items: []
};

const tasksSlice = createSlice({
  name: 'tasks',
  initialState,
  reducers: {
    addTask(state, action) {
      state.items.push(action.payload);
    },
    toggleTask(state, action) {
      const task = state.items.find((task) => task.id === action.payload);

      if (task) {
        task.completed = !task.completed;
      }
    },
    deleteTask(state, action) {
      state.items = state.items.filter((task) => task.id !== action.payload);
    }
  }
});

export const { addTask, toggleTask, deleteTask } = tasksSlice.actions;
export default tasksSlice.reducer;
```

Now connect it to the store:

```javascript
import { configureStore } from '@reduxjs/toolkit';
import tasksReducer from '../features/tasks/tasksSlice';

export const store = configureStore({
  reducer: {
    tasks: tasksReducer
  }
});
```


You created a slice to manage tasks and connected it to the store. The application now has a central place where all task data lives and can be updated.

Ontdek de kracht van Redux Toolkit in combinatie met React en versterk uw vaardigheden in state management. Deze cursus biedt een uitgebreide introductie tot Redux Toolkit, een krachtige bibliotheek voor het beheren van state. Leer hoe u uw Redux-configuratie kunt vereenvoudigen, complexe state-logica kunt stroomlijnen en efficiënte, schaalbare React-toepassingen kunt creëren.

Understand why Redux Toolkit exists and when it becomes useful. Recognize how state complexity grows in real applications and why simple approaches stop scaling.

Install Redux Toolkit and set up the store. Connect Redux to a React application and understand how data flows through the system.

Define state using slices and organize logic clearly. Create reducers, use generated actions, and keep state manageable as the application grows.

Read data from the store using useSelector and update it with useDispatch. Structure state correctly and avoid common mistakes when working with shared data.

Fetch data from APIs using createAsyncThunk. Manage loading and error states and keep the UI in sync with async updates.

Split state into multiple slices and organize files by feature. Combine reducers cleanly and maintain a clear structure as the application grows.

Build a complete application using Redux Toolkit. Implement CRUD features, handle async data, and improve the user experience with loading and error states.

Creating Global State for the App