JavaScript and React course ยท Module 5: useEffect and Custom Hooks

Memoization - React.memo, useMemo, and useCallback

6 min read ยท
In this lesson8

In outer space, resources are limited and must be used wisely. Similarly in the React world, application performance is of key importance. Memoization is an optimization technique that allows "remembering" results of expensive operations and reusing them when input data hasn't changed - similar to saving and reusing trajectory calculations instead of performing them from scratch.

What is memoization in React?

Memoization in React is a performance optimization mechanism that allows you to:

  • Avoid unnecessary component re-renders
  • Prevent re-execution of expensive calculations
  • Stabilize references to functions and objects

React.memo - component memoization

React.memo is a higher-order component (HOC) that wraps a component and prevents it from re-rendering if its props haven't changed.

Basic usage of React.memo

import React from 'react';

// Component without memoization
function PlanetInfo({ name, diameter, distance }) {
  console.log(`Rendering planet info: ${name}`);
  return (
    <div className="planet-info">
      <h2>{name}</h2>
      <p>Diameter: {diameter} km</p>
      <p>Distance from Sun: {distance} million km</p>
    </div>
  );
}

// Same component with memoization
const MemoizedPlanetInfo = React.memo(PlanetInfo);

// Parent component
function SolarSystem() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <button onClick={() => setCount(count + 1)}>
        Counter: {count}
      </button>

      {/* This component will only re-render when its props change */}
      <MemoizedPlanetInfo
        name="Mars"
        diameter={6779}
        distance={228}
      />
    </div>
  );
}

Notice that in the above example, even though the parent component SolarSystem renders again on every button click, the component MemoizedPlanetInfo will not re-render because its props remain unchanged.

Custom props comparison

By default React.memo compares props using shallow comparison. However, you can provide your own comparison function:

const MemoizedPlanetInfo = React.memo(
  PlanetInfo,
  (prevProps, nextProps) => {
    // Return true if you want to prevent re-rendering
    // Return false if you want to re-render the component
    return prevProps.name === nextProps.name &&
           prevProps.diameter === nextProps.diameter;
    // Note that we ignore changes to distance - the component won't re-render
    // when only this property changes
  }
);

useMemo - value memoization

Hook useMemo allows remembering the result of an expensive operation and reusing it as long as dependencies haven't changed.

When to use useMemo?

  1. For expensive calculations
  2. When creating reference objects as props for child components
  3. When creating large data structures
import React, { useState, useMemo } from 'react';

function AsteroidCalculator({ asteroids }) {
  const [filter, setFilter] = useState('all');

  // Expensive calculation - memoized for better performance
  const dangerousAsteroids = useMemo(() => {
    console.log('Calculating dangerous asteroids...');
    return asteroids.filter(asteroid => {
      // Simulation of expensive calculations
      let isDangerous = false;
      for (let i = 0; i < 10000; i++) {
        if (asteroid.velocity > 20 && asteroid.size > 1000 && asteroid.distance < 50000000) {
          isDangerous = true;
        }
      }
      return isDangerous;
    });
  }, [asteroids]); // Calculation will be re-executed only when the asteroids array changes

  // This calculation is also memoized but depends on the filter
  const displayedAsteroids = useMemo(() => {
    console.log('Filtering asteroids...');
    if (filter === 'all') return asteroids;
    if (filter === 'dangerous') return dangerousAsteroids;
    return [];
  }, [filter, asteroids, dangerousAsteroids]);

  return (
    <div>
      <div>
        <button onClick={() => setFilter('all')}>All</button>
        <button onClick={() => setFilter('dangerous')}>Nobezpieczne</button>
      </div>
      <h2>Asteroids ({displayedAsteroids.length}):</h2>
      <ul>
        {displayedAsteroids.map(asteroid => (
          <li key={asteroid.id}>{asteroid.name}</li>
        ))}
      </ul>
    </div>
  );
}

useCallback - function memoization

Hook useCallback is similar to useMemo, but instead of remembering the function's result, it remembers the function itself. It's particularly useful when passing functions as props to memoized child components.

import React, { useState, useCallback } from 'react';

function MissionControl() {
  const [missionStatus, setMissionStatus] = useState('preparing');
  const [fuelLevel, setFuelLevel] = useState(100);

  // Z useCallback, function is recreated only when fuelLevel changes
  const startMission = useCallback(() => {
    if (fuelLevel > 20) {
      setMissionStatus('in-progress');
      console.log(`Mission started with fuel level: ${fuelLevel}%`);
    } else {
      console.log('Not enough fuel to start mission');
    }
  }, [fuelLevel]); // Dependency: function recreated when fuelLevel changes

  const abortMission = useCallback(() => {
    setMissionStatus('aborted');
    console.log('Mission aborted!');
  }, []); // Empty dependency array - function created only once

  return (
    <div>
      <h2>Mission status: {missionStatus}</h2>
      <p>Fuel level: {fuelLevel}%</p>

      <button onClick={() => setFuelLevel(prev => Math.max(0, prev - 10))}>
        Use fuel
      </button>

      {/* Passing memoized functions as props */}
      <MemoizedControlPanel
        onStart={startMission}
        onAbort={abortMission}
        fuelLevel={fuelLevel}
      />
    </div>
  );
}

// Memoized child component that receives functions as props
const ControlPanel = React.memo(({ onStart, onAbort, fuelLevel }) => {
  console.log('Rendering control panel');

  return (
    <div className="control-panel">
      <h3>Control panel</h3>
      <button onClick={onStart} disabled={fuelLevel <= 20}>
        Start
      </button>
      <button onClick={onAbort}>
        Abort mission
      </button>
    </div>
  );
});

const MemoizedControlPanel = React.memo(ControlPanel);

Comparing memoization techniques and when to use them

TechniqueUse caseWhen to use
React.memoComponentWhen a component frequently receives the same props
useMemoValueFor expensive calculations and complex data structures
useCallbackFunctionWhen passing functions as props to memoized components

Common mistakes and pitfalls

1. Over-memoization

// Not optimal - too simple a value to memoize
const count = useMemo(() => 1 + 2, []);

// Not optimal - simple function that doesn't need memoization
const handleClick = useCallback(() => {
  console.log('Clicked!');
}, []);

2. Forgetting dependencies

// Not safe - missing dependency 'value'
const processedData = useMemo(() => {
  return heavyProcessing(value);
}, []); // Should be [value]

3. Too many dependencies

// May reduce memoization effectiveness
const result = useMemo(() => {
  return computeResult(a, b);
}, [a, b, c, d, e]); // Too many dependencies - memoization may be ineffective

Use memoization wisely

  1. Don't optimize prematurely - use profilers first to identify actual performance issues
  2. Apply memoization selectively - only where it's actually needed
  3. Remember the cost - memoization also has its cost, which may outweigh the gains for simpler operations

Summary

Memoization in React is a powerful optimization technique that - like conserving resources on a spaceship - helps efficiently manage application performance. Use it wisely:

  • Use React.memo for components that frequently re-render with the same props
  • Use useMemo for expensive calculations and creating complex data structures
  • Use useCallback to stabilize function references passed down the component tree

However, remember that like any optimization technique, memoization has its cost and should be applied judiciously, where it actually brings performance benefits.

Code for this lesson: App.jsx
import React, { useState, useMemo, useCallback, memo, useRef } from 'react';

// React.memo - component memoization
const SpaceShip = memo(function SpaceShip({ name, speed, onSelect }) {
  console.log(`Rendering SpaceShip: ${name}`);

  return (
    <div className="spaceship" onClick={() => onSelect(name)}>
      <h3>{name}</h3>
      <p>Speed: {speed} km/s</p>
    </div>
  );
});

// useMemo - value memoization
function ExpensiveCalculation({ numbers }) {
  const [filter, setFilter] = useState('');

  // useMemo prevents recalculation on every render
  const stats = useMemo(() => {
    console.log('Calculating statistics...');

    // Simulating an expensive operation
    const sum = numbers.reduce((a, b) => a + b, 0);
    const avg = sum / numbers.length;
    const max = Math.max(...numbers);
    const min = Math.min(...numbers);

    return { sum, avg, max, min };
  }, [numbers]); // Only when numbers changes

  const filteredNumbers = useMemo(() => {
    if (!filter) return numbers;
    const threshold = parseInt(filter) || 0;
    return numbers.filter(n => n >= threshold);
  }, [numbers, filter]);

  return (
    <div className="demo-card">
      <h2>useMemo - Statistics</h2>
      <div className="stats">
        <div className="stat">Sum: {stats.sum}</div>
        <div className="stat">Average: {stats.avg.toFixed(2)}</div>
        <div className="stat">Min: {stats.min}</div>
        <div className="stat">Max: {stats.max}</div>
      </div>
      <input
        type="number"
        value={filter}
        onChange={(e) => setFilter(e.target.value)}
        placeholder="Filter >= value"
      />
      <div className="filtered">
        Filtered: [{filteredNumbers.join(', ')}]
      </div>
    </div>
  );
}

// useCallback - function memoization
function SpaceFleet() {
  const [ships] = useState([
    { name: 'Apollo', speed: 11 },
    { name: 'Voyager', speed: 17 },
    { name: 'Enterprise', speed: 299792 },
  ]);
  const [selected, setSelected] = useState(null);
  const [count, setCount] = useState(0);

  // Without useCallback - a new function on every render
  // const handleSelect = (name) => setSelected(name);

  // With useCallback - the same function reference
  const handleSelect = useCallback((name) => {
    setSelected(name);
  }, []);

  return (
    <div className="demo-card">
      <h2>useCallback - Fleet</h2>
      <p className="hint">Open the console - see which ships re-render</p>

      <div className="fleet">
        {ships.map(ship => (
          <SpaceShip
            key={ship.name}
            name={ship.name}
            speed={ship.speed}
            onSelect={handleSelect}
          />
        ))}
      </div>

      {selected && <p className="selected">Selected: {selected}</p>}

      <div className="counter-section">
        <button onClick={() => setCount(c => c + 1)}>
          Counter: {count} (causes re-render)
        </button>
      </div>
    </div>
  );
}

// Comparison with and without memoization
function MemoizationComparison() {
  const [value, setValue] = useState(0);
  const calls = useRef({ with: 0, without: 0 });

  // Function WITHOUT memoization
  const expensiveWithout = () => {
    calls.current.without += 1;
    let result = 0;
    for (let i = 0; i < 1000; i++) {
      result += Math.sqrt(i);
    }
    return result;
  };

  // Function WITH memoization
  const expensiveWith = useMemo(() => {
    calls.current.with += 1;
    let result = 0;
    for (let i = 0; i < 1000; i++) {
      result += Math.sqrt(i);
    }
    return result;
  }, []); // Empty array = calculate once

  const resultWithout = expensiveWithout();

  return (
    <div className="demo-card">
      <h2>Comparison</h2>
      <div className="comparison">
        <div className="box without">
          <h3>Without useMemo</h3>
          <p>Calls: {calls.current.without}</p>
          <p className="result">{resultWithout.toFixed(2)}</p>
        </div>
        <div className="box with">
          <h3>With useMemo</h3>
          <p>Calls: {calls.current.with}</p>
          <p className="result">{expensiveWith.toFixed(2)}</p>
        </div>
      </div>
      <button onClick={() => setValue(v => v + 1)}>
        Force re-render ({value})
      </button>
    </div>
  );
}

function App() {
  const [numbers] = useState([23, 45, 12, 67, 89, 34, 56, 78, 90, 11]);

  return (
    <div className="app">
      <h1>Memoization in React</h1>
      <p className="subtitle">React.memo, useMemo, useCallback</p>
      <div className="demos">
        <ExpensiveCalculation numbers={numbers} />
        <SpaceFleet />
        <MemoizationComparison />
      </div>
    </div>
  );
}

export default App;

Docs entries used in this lesson

Spotted a mistake in this lesson?

Hands-on tasks in the game

  • Horizontal ordering

    Arrange the correct useMemo syntax for memoizing computations:

  1. Put in orderuseMemo Syntax with a Computation Function

Useful articles