Summary  
This chapter explains how to use Redux’s useDispatch hook to dispatch actions from a component, triggering reducers to update the application state. It emphasizes unidirectional data flow and predictable state changes by sending actions instead of mutating state directly.

General domain of usage  
Web frontend development


To change state in Redux, you send an action to the store. This is done using the `useDispatch` hook.



## Dispatching an Action

Inside a component, call `useDispatch` and use it to trigger actions:

```javascript
import { useDispatch } from 'react-redux';
import { increment } from './counterSlice';

function Counter() {
  const dispatch = useDispatch();

  return (
    <button onClick={() => dispatch(increment())}>
      Increase
    </button>
  );
}
```

When the button is clicked, the action is sent to the store and the state is updated.





## How It Works
You don't update state directly. Instead, you dispatch an action, and Redux decides how the state should change using reducers.


This approach keeps state updates predictable. All changes go through the same flow, which makes the application easier to understand and debug.


Découvrez la puissance de Redux Toolkit associé à React et perfectionnez vos compétences en gestion d'état. Ce cours présente de manière exhaustive Redux Toolkit, une bibliothèque puissante pour la gestion d'état. Apprenez à simplifier la configuration de Redux, à rationaliser la logique d'état complexe et à créer des applications React efficaces et évolutives.

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.

Updating State with useDispatch

Dispatching an Action

How It Works