React Hooks are a less complicated solution to encapsulate stateful conduct and unwanted side effects in practical parts as a substitute of lessons. Some hooks are simpler to grasp than others, due to this fact this collection of posts will deal with demystifying the hooks that aren’t as easy.

To date, now we have explored useCallback, useMemo, useRef, and useContext so ensure that to checkout my earlier posts in the event you haven’t already. This week, let’s begin with the fundamentals by explaining the JavaScript cut back technique. As soon as we discover the fundamentals, will probably be a lot simpler to grasp the useReducer hook, in addition to how and when to make use of it in your code.

What’s a reducer?

A reducer is the motion that shall be executed to be able to get just one worth. The objective of a reducer is to cut back (…duh!). The worth returned may very well be a quantity, a string, an array and even an object, so long as it’s a singular worth. Furthermore, it is very important spotlight that reducers return a brand new worth as a substitute of mutating your preliminary worth.

reduces are very helpful while you wish to acquire a single worth after making use of some logic to a bunch of values. As an example, if you wish to add up an array of numbers to acquire a complete worth as we do within the following instance.

We apply the JavaScript cut back technique to an array of numbers known as nums = [1,2,3,4,5]. The cut back technique takes two parameters:

reducer – a perform that gives directions to acquire one worth. On this case, to sum up all of the given values within the nums array.

const reducer = (accumulator, currentValue) => accumulator + currentValue;

initialValue – the place to begin worth when implementing the reducer perform’s directions. In our instance, we outline our preliminary worth as zero so the entire worth returned displays solely the sum of the values within the array nums.

const initialValue = zero;

Now that we outlined the weather concerned, let’s see all of it collectively. The cut back technique takes our initialValue and builds on it by following the directions given below the reducer perform, including every worth within the nums array till it is ready to return one complete worth.

// reducer technique - the motion that shall be executed to be able to get one worth
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// array of values that we wish to add up
const nums = [1,2,three,four,5];

// preliminary worth set to zero
const initialValue = zero;

// JavaScript cut back technique receives two parameters: the reducer perform and preliminary worth outlined above
const totalValue = nums.cut back(reducer, initialValue);

What’s useReducer()?

The useReducer hook is used with state administration. It receives the next parameters:

reducer – a perform that gives directions on learn how to handle state. It takes two parameters state and motion and it returns a brand new state.

// reducer kind
(state, motion) => newState

initialState – the place to begin worth. It’s going to change in keeping with the reducer directions.

Does it look acquainted? Nicely yeah… It takes related parameters because the cut back perform defined above. Nevertheless, the useReducer hook doesn’t return only one worth as cut back does. As an alternative it returns two components as an array, the present state and a dispatch perform.

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

In case you are conversant in React hooks, you most likely have used useState earlier than. Let’s examine these two hooks

// useState implementation
const [state, setState] = useState(initialState);

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

useReducer and useState each return a stateful worth (state), and a perform to replace the state (setState and dispatch). As well as, each hooks obtain an preliminary state worth (initialValue). The principle distinction in these two initializations is that useReducer additionally takes a reducer perform, which shall be known as after we use the returned dispatch perform. Let’s discover how useReducer works within the subsequent part.

How you can use useReducer?

Alt Text

Typically one of the simplest ways to elucidate how one thing works is with an instance so let’s check out one. Here’s a definition for an initialState, additionally known as a retailer of knowledge, that accommodates an inventory of canines up for adoption with their identify, breed, and adoption standing.

const initialState = [
      identify: "Charlie",
      breed: "Pitbull",
      adopted: true,

Now let’s create a reducer perform to replace our initialState record of canines as they get adopted or returned. This perform takes the next parameters:

state – the present state of our canines in adoption.

motion – an object that accommodates the next:

  • kind of motion we wish to carry out. On this case, we’re solely constructing two choices, undertake or ‘return’.

  • payload elective information. In our instance, we’ll cross the canine’s identify so we will establish which canine received adopted or returned.

const reducer = (state, motion) => 

Now It’s lastly time to implement our useReducer() hook! Check out the instance under, the place we outline our useReducer() hook with the initialState (adoption canines record) and the reducer perform we created to deal with their adoption standing.

We iterate by way of our canines record state and show a button that can say undertake or return relying on their present adoption standing. The onClick handler assigned to our button will name a perform answerable for utilizing the dispatch perform returned by our useReducer() hook passing the kind of motion it must carry out and the canine’s identify as payload.

const adoptDog = identify => dispatch( kind: 'ADOPT', payload: identify );

The dispatch perform will cross this information to our reducer perform, the place we’ll use the kind to establish what part of code must run and the payload to search out the canine report we have to replace.

When do you have to use useReducer?

When explaining the useReducer hook, we in contrast it to useState so that you may be questioning… when ought to I take advantage of useReducer and when ought to I take advantage of useState?

The useReducer hook is a most well-liked different to useState when coping with the next:

  • Advanced state logic that includes a number of sub-values
  • State values that depend upon the state of different state components


  • The JavaScript cut back technique could be very helpful while you wish to acquire a single worth after making use of some logic to a bunch of values.

  • reducers return a brand new worth as a substitute of mutating your preliminary worth.

  • The useReducer hook is used with state administration.

  • The useReducer hook must be used when coping with complicated state logic, a number of sub-values, or when your state will depend on state sub-values.

I hope this put up helped you get a greater understanding of the JavaScript cut back technique and the useReducer() hook and that you’ll begin profiting from these ideas in your future initiatives.

I take pleasure in creating content material that explains ideas in actually easy phrases. Why? As a result of data is energy and I wish to assist newbie builders increase their data and thrive.

Give this put up a response in the event you discovered it useful and observe me on Twitter and to maintain up with new posts!


Please enter your comment!
Please enter your name here

This site uses Akismet to reduce spam. Learn how your comment data is processed.