React provides three main tools for memoization to optimize component performance by minimizing unnecessary re-renders and re-computations:
1. useMemo
– Memoize Computed Values
- Purpose: Caches the result of a computation, only re-calculating if dependencies change.
-
Usage: Use for expensive calculations or derived data that should only update with specific dependencies.
const memoizedValue = useMemo(() => complexCalculation(), [dependencies]);
-
Best Practices:
- Include all dependencies used within the function in the dependency array.
- Avoid creating new references (arrays, objects) or inline functions within
useMemo
. -
Note: Don’t use
useMemo
for functions; it caches values, not function references.
2. useCallback
– Memoize Function References
- Purpose: Caches a function reference, preventing re-creation on each render.
-
Usage: Use for stable function references, especially for callbacks (e.g., event handlers) passed to child components.
const memoizedFunction = useCallback(() => { /* logic */ }, [dependencies]);
-
Best Practices:
- Include all dependencies used within the function in the dependency array to avoid stale values.
- Avoid declaring inline functions within
useCallback
, as this can break memoization. -
Note: Use
useCallback
for functions only. MisusinguseCallback
for values results in inefficient code with unnecessary function calls.
3. React.memo
– Memoize Entire Components
- Purpose: Prevents a functional component from re-rendering if its props haven’t changed.
-
Usage: Use to optimize child components that don’t need to re-render when the parent changes.
const MemoizedComponent = React.memo(ChildComponent);
-
Best Practices:
- Use with components receiving stable props or props that rarely change.
- Avoid frequent changes in props (like new objects/arrays) to maximize
React.memo
’s effectiveness. -
Note: Works well with
useCallback
memoized functions to maintain stable props passed to child components.
Key Points to Remember
-
Use
useMemo
for values anduseCallback
for functions.-
Using
useMemo
for functions results in immediate execution, not a stable function reference. -
Using
useCallback
for values returns a function, which leads to inefficient code with extra function calls.
-
Using
-
Memoization Summary:
-
useMemo
: Caches computed values (return values of functions). -
useCallback
: Caches function references (callbacks). -
React.memo
: Caches entire components based on props to prevent re-renders from parent updates.
-
- Selectively Use Memoization: Memoization improves performance when used correctly but can add complexity if overused or misused.
Top comments (0)