Understanding Memoization in React

5 min read

What's Memoization

Memoization is the process of caching the results of expensive function calls and returning the cached result when the same inputs occur again. In React, useMemo and useCallback are hooks that leverage this concept to avoid unnecessary calculations or renders.

Using useMemo

useMemo memoizes values. This is particularly useful when you have a computation that shouldn't be executed on every render unless certain dependencies change.

import React, { useMemo } from 'react';

const Component = ({ numbers }) => {
  const sum = useMemo(() => {
    return numbers.reduce((total, num) => total + num, 0);
  }, [numbers]);

  return <div>Sum: {sum}</div>;

In this example, useMemo ensures that the sum is recalculated only when the numbers array changes.

Using useCallback

useCallback is similar to useMemo, but it's used for memoizing functions. This is useful when passing callbacks to optimized child components that rely on reference equality to prevent unnecessary renders.

import React, { useCallback } from 'react';

const ParentComponent = ({prop}) => {
  const handleFilterChange = useCallback((filterCriteria) => {
    // filter logic 
  }, [prop]);

  return <FilterComponent onFilterChange={handleFilterChange} />;

In this example, the handleFilterChange function within ParentComponent is dependent on the prop value. When prop changes, useCallback will return a new version of handleFilterChange to reflect the updated logic based on the new prop value. This ensures that the filter logic always has access to the current value of prop, providing a balance between performance optimization and dynamic behavior based on props.


Memoization with useMemo and useCallback can significantly improve the performance of your React applications by avoiding unnecessary computations and re-renders. It's important to use these hooks judiciously, as overuse can lead to memory overhead and complex code. As always, profile your application's performance to make informed optimization decisions.