JavaScript and React course ยท Module 5: useEffect and Custom Hooks
Memoization - React.memo, useMemo, and useCallback
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?
- For expensive calculations
- When creating reference objects as props for child components
- 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
| Technique | Use case | When to use |
|---|---|---|
| React.memo | Component | When a component frequently receives the same props |
| useMemo | Value | For expensive calculations and complex data structures |
| useCallback | Function | When 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 ineffectiveUse memoization wisely
- Don't optimize prematurely - use profilers first to identify actual performance issues
- Apply memoization selectively - only where it's actually needed
- 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.memofor components that frequently re-render with the same props - Use
useMemofor expensive calculations and creating complex data structures - Use
useCallbackto 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: