Extracting State Logic into a Reducer
Components with many state updates spread across many event handlers can get overwhelming. For these cases, you can consolidate all the state update logic outside your component in a single function, called a reducer.
- What a reducer function is
- How to refactor
useStatetouseReducer - When to use a reducer
- How to write one well
Consolidate state logic with a reducer
As your components grow in complexity, it can get harder to see at a glance all the different ways in which a component's state gets updated. For example, the TaskApp component below holds an array of tasks in state and uses three different event handlers to add, remove, and edit tasks:
```js src/App.js import { useState } from 'react'; import AddTask from './AddTask.js'; import TaskList from './TaskList.js';
export default function TaskApp() { const [tasks, setTasks] = useState(initialTasks);
function handleAddTask(text) { setTasks([ ...tasks, { id: nextId++, text: text, done: false, }, ]); }
function handleChangeTask(task) { setTasks( tasks.map((t) => { if (t.id === task.id) { return task; } else { return t; } }) ); }
function handleDeleteTask(taskId) { setTasks(tasks.filter((t) => t.id !== taskId)); }
return ( <>
Prague itinerary
let nextId = 3; const initialTasks = [ {id: 0, text: 'Visit Kafka Museum', done: true}, {id: 1, text: 'Watch a puppet show', done: false}, {id: 2, text: 'Lennon Wall pic', done: false}, ];
```js src/AddTask.js hidden
import { useState } from 'react';
export default function AddTask({onAddTask}) {
const [text, setText] = useState('');
return (
<>
<input
placeholder="Add task"
value={text}
onChange={(e) => setText(e.target.value)}
/>
<button
onClick={() => {
setText('');
onAddTask(text);
}}>
Add
</button>
</>
);
}
```js src/TaskList.js hidden import { useState } from 'react';
export default function TaskList({tasks, onChangeTask, onDeleteTask}) { return (
-
{tasks.map((task) => (
-
function Task({task, onChange, onDelete}) { const [isEditing, setIsEditing] = useState(false); let taskContent; if (isEditing) { taskContent = ( <> { onChange({ ...task, text: e.target.value, }); }} /> </> ); } else { taskContent = ( <> {task.text} </> ); } return ( ); }
```css
button {
margin: 5px;
}
li {
list-style-type: none;
}
ul,
li {
margin: 0;
padding: 0;
}
Each of its event handlers calls setTasks in order to update the state. As this component grows, so does the amount of state logic sprinkled throughout it. To reduce this complexity and keep all your logic in one easy-to-access place, you can move that state logic into a single function outside your component, called a "reducer".
Reducers are a different way to handle state. You can migrate from useState to useReducer in three steps:
- Move from setting state to dispatching actions.
- Write a reducer function.
- Use the reducer from your component.
Step 1: Move from setting state to dispatching actions
Your event handlers currently specify what to do by setting state:
function handleAddTask(text) {
setTasks([
...tasks,
{
id: nextId++,
text: text,
done: false,
},
]);
}
function handleChangeTask(task) {
setTasks(
tasks.map((t) => {
if (t.id === task.id) {
return task;
} else {
return t;
}
})
);
}
function handleDeleteTask(taskId) {
setTasks(tasks.filter((t) => t.id !== taskId));
}
Remove all the state setting logic. What you are left with are three event handlers:
handleAddTask(text)is called when the user presses "Add".handleChangeTask(task)is called when the user toggles a task or presses "Save".handleDeleteTask(taskId)is called when the user presses "Delete".
Managing state with reducers is slightly different from directly setting state. Instead of telling React "what to do" by setting state, you specify "what the user just did" by dispatching "actions" from your event handlers. (The state update logic will live elsewhere!) So instead of "setting tasks" via an event handler, you're dispatching an "added/changed/deleted a task" action. This is more descriptive of the user's intent.
function handleAddTask(text) {
dispatch({
type: 'added',
id: nextId++,
text: text,
});
}
function handleChangeTask(task) {
dispatch({
type: 'changed',
task: task,
});
}
function handleDeleteTask(taskId) {
dispatch({
type: 'deleted',
id: taskId,
});
}
The object you pass to dispatch is called an "action":
```js {3-7} function handleDeleteTask(taskId) { dispatch( // "action" object: { type: 'deleted', id: taskId, } ); }
It is a regular JavaScript object. You decide what to put in it, but generally it should contain the minimal information about _what happened_. (You will add the `dispatch` function itself in a later step.)
> [!NOTE]
>
> An action object can have any shape.
>
> By convention, it is common to give it a string `type` that describes what happened, and pass any additional information in other fields. The `type` is specific to a component, so in this example either `'added'` or `'added_task'` would be fine. Choose a name that says what happened!
>
```js
dispatch({
// specific to component
type: 'what_happened',
// other fields go here
});
Step 2: Write a reducer function
A reducer function is where you will put your state logic. It takes two arguments, the current state and the action object, and it returns the next state:
function yourReducer(state, action) {
// return next state for React to set
}
React will set the state to what you return from the reducer.
To move your state setting logic from your event handlers to a reducer function in this example, you will:
- Declare the current state (
tasks) as the first argument. - Declare the
actionobject as the second argument. - Return the next state from the reducer (which React will set the state to).
Here is all the state setting logic migrated to a reducer function:
function tasksReducer(tasks, action) {
if (action.type === 'added') {
return [
...tasks,
{
id: action.id,
text: action.text,
done: false,
},
];
} else if (action.type === 'changed') {
return tasks.map((t) => {
if (t.id === action.task.id) {
return action.task;
} else {
return t;
}
});
} else if (action.type === 'deleted') {
return tasks.filter((t) => t.id !== action.id);
} else {
throw Error('Unknown action: ' + action.type);
}
}
Because the reducer function takes state (tasks) as an argument, you can declare it outside of your component. This decreases the indentation level and can make your code easier to read.
[!NOTE]
The code above uses if/else statements, but it's a convention to use switch statements inside reducers. The result is the same, but it can be easier to read switch statements at a glance.
We'll be using them throughout the rest of this documentation like so:
function tasksReducer(tasks, action) {
switch (action.type) {
case 'added': {
return [
...tasks,
{
id: action.id,
text: action.text,
done: false,
},
];
}
case 'changed': {
return tasks.map((t) => {
if (t.id === action.task.id) {
return action.task;
} else {
return t;
}
});
}
case 'deleted': {
return tasks.filter((t) => t.id !== action.id);
}
default: {
throw Error('Unknown action: ' + action.type);
}
}
}
We recommend wrapping each
caseblock into the{and}curly braces so that variables declared inside of differentcases don't clash with each other. Also, acaseshould usually end with areturn. If you forget toreturn, the code will "fall through" to the nextcase, which can lead to mistakes!If you're not yet comfortable with switch statements, using if/else is completely fine.
[!INFO]
Why are reducers called this way?
Although reducers can "reduce" the amount of code inside your component, they are actually named after the
reduce()operation that you can perform on arrays.The
reduce()operation lets you take an array and "accumulate" a single value out of many:
const arr = [1, 2, 3, 4, 5];
const sum = arr.reduce(
(result, number) => result + number
); // 1 + 2 + 3 + 4 + 5
The function you pass to
reduceis known as a "reducer". It takes the result so far and the current item, then it returns the next result. React reducers are an example of the same idea: they take the state so far and the action, and return the next state. In this way, they accumulate actions over time into state.You could even use the
reduce()method with aninitialStateand an array ofactionsto calculate the final state by passing your reducer function to it:
```js src/index.js active import tasksReducer from './tasksReducer.js';
let initialState = []; let actions = [ {type: 'added', id: 1, text: 'Visit Kafka Museum'}, {type: 'added', id: 2, text: 'Watch a puppet show'}, {type: 'deleted', id: 1}, {type: 'added', id: 3, text: 'Lennon Wall pic'}, ];
let finalState = actions.reduce(tasksReducer, initialState);
const output = document.getElementById('output'); output.textContent = JSON.stringify(finalState, null, 2);
```js src/tasksReducer.js
export default function tasksReducer(tasks, action) {
switch (action.type) {
case 'added': {
return [
...tasks,
{
id: action.id,
text: action.text,
done: false,
},
];
}
case 'changed': {
return tasks.map((t) => {
if (t.id === action.task.id) {
return action.task;
} else {
return t;
}
});
}
case 'deleted': {
return tasks.filter((t) => t.id !== action.id);
}
default: {
throw Error('Unknown action: ' + action.type);
}
}
}
```html public/index.html
>
> You probably won't need to do this yourself, but this is similar to what React does!
>
### Step 3: Use the reducer from your component
Finally, you need to hook up the `tasksReducer` to your component. Import the `useReducer` Hook from React:
```js
import { useReducer } from 'react';
Then you can replace useState:
const [tasks, setTasks] = useState(initialTasks);
with useReducer like so:
const [tasks, dispatch] = useReducer(tasksReducer, initialTasks);
The useReducer Hook is similar to useState—you must pass it an initial state and it returns a stateful value and a way to set state (in this case, the dispatch function). But it's a little different.
The useReducer Hook takes two arguments:
- A reducer function
- An initial state
And it returns:
- A stateful value
- A dispatch function (to "dispatch" user actions to the reducer)
Now it's fully wired up! Here, the reducer is declared at the bottom of the component file:
```js src/App.js import { useReducer } from 'react'; import AddTask from './AddTask.js'; import TaskList from './TaskList.js';
export default function TaskApp() { const [tasks, dispatch] = useReducer(tasksReducer, initialTasks);
function handleAddTask(text) { dispatch({ type: 'added', id: nextId++, text: text, }); }
function handleChangeTask(task) { dispatch({ type: 'changed', task: task, }); }
function handleDeleteTask(taskId) { dispatch({ type: 'deleted', id: taskId, }); }
return ( <>
Prague itinerary
function tasksReducer(tasks, action) { switch (action.type) { case 'added': { return [ ...tasks, { id: action.id, text: action.text, done: false, }, ]; } case 'changed': { return tasks.map((t) => { if (t.id === action.task.id) { return action.task; } else { return t; } }); } case 'deleted': { return tasks.filter((t) => t.id !== action.id); } default: { throw Error('Unknown action: ' + action.type); } } }
let nextId = 3; const initialTasks = [ {id: 0, text: 'Visit Kafka Museum', done: true}, {id: 1, text: 'Watch a puppet show', done: false}, {id: 2, text: 'Lennon Wall pic', done: false}, ];
```js src/AddTask.js hidden
import { useState } from 'react';
export default function AddTask({onAddTask}) {
const [text, setText] = useState('');
return (
<>
<input
placeholder="Add task"
value={text}
onChange={(e) => setText(e.target.value)}
/>
<button
onClick={() => {
setText('');
onAddTask(text);
}}>
Add
</button>
</>
);
}
```js src/TaskList.js hidden import { useState } from 'react';
export default function TaskList({tasks, onChangeTask, onDeleteTask}) { return (
-
{tasks.map((task) => (
-
function Task({task, onChange, onDelete}) { const [isEditing, setIsEditing] = useState(false); let taskContent; if (isEditing) { taskContent = ( <> { onChange({ ...task, text: e.target.value, }); }} /> </> ); } else { taskContent = ( <> {task.text} </> ); } return ( ); } ```
