React-Hooks: What is The Difference Between useCallback And useMemo? by@sahil-sachdeva
26,988 reads

React-Hooks: What is The Difference Between useCallback And useMemo?

tldt arrow
Read on Terminal Reader

Too Long; Didn't Read

React-Hooks are methods and functions that can "hook into" React's state and lifecycle features. Hooks allow the useState and other React features without writing a single class. UseMemo is used in the functional component of React to return a memoized value. UseUseCallBack and useMemo hooks cache a function and store a memory-mapped value. The major difference is that useCallBack will memory the returned value, whereas useMemO will memory function.

Company Mentioned

Mention Thumbnail
featured image - React-Hooks: What is The Difference Between useCallback And useMemo?
Sahil Sachdeva HackerNoon profile picture


Sahil Sachdeva

Founder Digi Bharata | Tech Blogger

Learn More
react to story with heart

Learn the Correct Method to useCallback And useMemo

Are you a React developer? Yes! Then, this blog is preferably for you. Today, we are going to share a complete guide on React-Hooks. In the latest version of React 16.8, two built-in hooks or new features are introduced to optimize the performance, such as useCallback and useMemo

Many react programmers may feel quite confused about the difference between useCallBack and useMemo. Why do useMemo and useCallback expect a function? Not to worry if you have the same query or concern about React-Hooks. Here we are trying to share the best and most accurate information. I hope you find your solutions here.

Let’s get started.

What are React-Hooks?

Hooks basically are a new feature introduced in React 16.8; it allows the useState and other React features without writing a single class. Hooks are methods and functions that can "hook into" React's state and lifecycle features.

What is useCallback?

The useCallback hook is used when a child component is rerendering over and over again without any need. 

Purpose of useCallback

By using useCallback, you can prevent unnecessarily re-rendering components by returning the same instance of the function that is passed instead of creating a new one each time.

Using useCallback hooks is useful when a child component is rendering again and again without ever needing to.

Passing an array of dependencies and a memorialized callback will result in a memoized version of the callback that is only modified when any dependence changes.

Syntax of useCallback: 

const memoizedCallback = useCallback(

  () => {

    doSomething(a, b);


  [a, b],


What is useMemo? 

The useMemo hook is used in the functional component of React to return a memoized value.

Purpose of useMemo

In computer science, memoization is a concept used in general when we can save re-compilation time by returning the cached result. In the functional component of React, useMemo hooks provide memory-mapped values.

Using useMemo when very little processing is involved is not really wise. In cases with very little processing, using it could add extra overhead. However, useMemo works well to avoid extra rendering unnecessarily.

Now, you must be wondering what memoization is in React-Hooks. 


Memoization refers to the concept of not recompiling a function with the same argument again for the next run because it returns the cached result the next time that it is called.

At this point, you must have a better or clearer understanding of React-Hooks: useCallback and useMemo. Also, the purpose and usage of both. Now, let’s move ahead with the next topic of discussion. 

At first glance, it might look like useCallback and useMemo usage are quite similar, however, it’s not. Therefore, there are many chances to get confused about when to utilize useCallback and useMemo. 

In order to eliminate all the confusion about useCallback and useMemo, let’s have a look at the difference between both hooks.

Syntax of useMemo:

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

Difference Between useMemo And useCallback

In both useMemo and useCallback, the hook accepts a function and an array of dependencies. The major difference between useCallback and useMemo is that useCallback will memory the returned value, whereas useMemo will memory the function. Essentially, the only difference between these hooks is that one caches a value type, and the other caches a function.

Let's take an example; if the computationally expensive code accepts arguments and returns a value, you would need to use useMemo so you could keep referencing that value between renders without re-running the computationally expensive code.

On the other hand, in order to keep a function instance persistent for multiple renders, useCallback is needed. This is like placing a function outside the scope of your react component to keep it intact.

In What Way Does The Dependency Array Work With These Hooks?

You might be familiar with the dependency array -  useMemo and useCallback if you have ever used the React-Hook useEffect. However, if you’re not familiar with the term, then don't worry. We will explain what useEffect means.


The useEffect (callback, dependencies) hook is used to handle side-effects in functional components. The callback argument is the logic to be used. Dependencies is a list of dependencies of the side-effect: being props or state values.

Using this Hook, you tell React that your component needs to perform some action after rendering. When React updates the DOM, it stores the effect you pass (we'll call it "effect"). We can also perform data fetching or call another imperative API to achieve this result as well as setting the document title.

Syntax of useEffect:

useEffect(() => {

  const subscription = props.source.subscribe();

  return () => {

    // Clean up the subscription




Now, let’s move on to how the dependency array works with these hooks 

The useCallback, useMemo, and useEffect methods are ways to enhance performance between re-rendering of components in React-based applications.

These functions control some of the features offered by class-based components, such as the persistence of dedicated states through render calls and the appearance of components at various stages of their lifecycle.

Basically, you provide an array of values or variables inside the function you provide to the hook.

Here you will find the best platform from where you hire react native developers. Hope you find it informative.


. . . comments & more!
Hackernoon hq - po box 2206, edwards, colorado 81632, usa