Avoiding unnecessary renders in React - Cheat Sheet & Quick Revision

Recall & Review

beginner

What causes unnecessary renders in React components?

Unnecessary renders happen when React re-renders a component even though its output would not change. This can be caused by changing state or props that don't affect the UI, or by passing new object or function references every time.

beginner

How does React.memo help avoid unnecessary renders?

React.memo is a higher-order component that wraps a functional component. It tells React to skip re-rendering the component if its props have not changed, improving performance by avoiding work when not needed.

intermediate

What is the purpose of useCallback in React?

useCallback returns a memoized version of a callback function that only changes if its dependencies change. This helps prevent passing new function references on every render, which can cause child components to re-render unnecessarily.

intermediate

Why should you avoid creating new objects or arrays inside component bodies without memoization?

Creating new objects or arrays inside components causes their references to change every render. If these are passed as props, React thinks the props changed and re-renders child components. Memoizing them with useMemo or useCallback avoids this.

intermediate

What role does useMemo play in avoiding unnecessary renders?

useMemo memoizes the result of a calculation or object creation so React reuses the same value between renders unless dependencies change. This prevents passing new references that cause child components to re-render.

Which React hook helps memoize a function to avoid unnecessary re-renders?

A useCallback

B useState

C useEffect

D useRef

useCallback memoizes functions so their references stay the same unless dependencies change, helping avoid unnecessary renders.

What does React.memo do?

A Runs side effects after render

B Prevents a component from rendering if its props haven't changed

C Automatically updates state

D Creates a new component

React.memo skips rendering a component if its props are the same as before, improving performance.

Why can passing new object literals as props cause unnecessary renders?

A Because React ignores objects

B Because React caches all objects

C Because objects are always equal

D Because objects are compared by reference, new objects look different each time

React compares props by reference, so new object literals create new references causing re-renders.

Which hook would you use to memoize a computed value to avoid recalculating it every render?

A useState

B useCallback

C useMemo

D useEffect

useMemo memoizes computed values so they are recalculated only when dependencies change.

What is a common sign that a React component is rendering unnecessarily?

A The UI looks the same but performance is slow

B The component never updates

C The component crashes

D The component only renders once

Unnecessary renders cause slow performance even though the UI output does not change.

Explain how React.memo, useCallback, and useMemo work together to avoid unnecessary renders.

Think about how React decides to re-render components based on props and function references.

Describe why creating new objects or functions inside a React component can cause performance issues.

Focus on how React compares props and why stable references matter.

Practice

1. What is the main purpose of using React.memo in a React component?

easy

A. To convert a class component into a functional component

B. To force the component to re-render every time the parent renders

C. To prevent re-rendering when the component's props have not changed

D. To automatically update the component's state

Solution

1. Step 1: Understand React.memo's role

   React.memo is a higher-order component that wraps a functional component to optimize rendering.

2. Step 2: Identify its effect on rendering

   It skips re-rendering the wrapped component if its props remain the same, improving performance.

3. Final Answer:

   To prevent re-rendering when the component's props have not changed -> Option C

4. Quick Check:

   React.memo skips renders if props unchanged = D [OK]

Hint: React.memo skips render if props stay the same [OK]

Common Mistakes:

• Thinking React.memo forces re-render
• Confusing React.memo with state updates
• Believing it converts component types

2. Which of the following is the correct syntax to memoize a function using useCallback in React?

easy

A. const memoizedFn = useCallback(() => { doSomething(); }, []);

B. const memoizedFn = useCallback(doSomething(), []);

C. const memoizedFn = useCallback(() => doSomething);

D. const memoizedFn = useCallback(() => { doSomething(); });

Solution

1. Step 1: Recall useCallback syntax

   useCallback takes a function and a dependency array, returning a memoized version of the function.

2. Step 2: Check each option's correctness

   const memoizedFn = useCallback(() => { doSomething(); }, []); correctly passes a function and an empty dependency array, memoizing the function properly.

3. Final Answer:

   const memoizedFn = useCallback(() => { doSomething(); }, []); -> Option A

4. Quick Check:

   useCallback needs function and dependencies = C [OK]

Hint: useCallback(fn, deps) memoizes function with dependencies [OK]

Common Mistakes:

• Calling the function inside useCallback instead of passing it
• Omitting the dependency array
• Passing function reference without parentheses incorrectly

3. Consider this React component:

const MyComponent = React.memo(({ count, onClick }) => {
  console.log('Rendered');
  return <button onClick={onClick}>Count: {count}</button>;
});

function App() {
  const [count, setCount] = React.useState(0);
  const handleClick = () => setCount(count + 1);
  return <MyComponent count={count} onClick={handleClick} />;
}

What will happen when App re-renders?

medium

A. MyComponent will never re-render because it is wrapped in React.memo

B. MyComponent will re-render every time because handleClick is recreated on each render

C. MyComponent will re-render only when count changes, ignoring onClick

D. MyComponent will re-render only when handleClick changes, ignoring count

Solution

1. Step 1: Understand React.memo and props

   React.memo skips re-render if props are shallowly equal. Here, onClick is a new function each render.

2. Step 2: Analyze function recreation

   Since handleClick is recreated on every render, its reference changes, causing MyComponent to re-render.

3. Final Answer:

   MyComponent will re-render every time because handleClick is recreated on each render -> Option B

4. Quick Check:

   New function prop breaks memo = B [OK]

Hint: New function props cause re-render despite React.memo [OK]

Common Mistakes:

• Assuming React.memo ignores function prop changes
• Thinking React.memo prevents all re-renders
• Ignoring function identity in props

4. You have this React code that causes unnecessary re-renders:

const Parent = () => {
  const [count, setCount] = React.useState(0);
  const increment = () => setCount(count + 1);
  return <Child onClick={increment} />;
};

const Child = React.memo(({ onClick }) => {
  console.log('Child rendered');
  return <button onClick={onClick}>Click</button>;
});

How can you fix the unnecessary re-renders of Child?

medium

A. Wrap increment in useCallback with count as dependency

B. Remove React.memo from Child

C. Move increment outside the Parent component

D. Use useMemo to memoize count

Solution

1. Step 1: Identify cause of re-renders

   The increment function is recreated on every render, changing its reference and causing Child to re-render.

2. Step 2: Apply useCallback to memoize function

   Wrapping increment in useCallback with count dependency keeps the same function reference unless count changes.

3. Final Answer:

   Wrap increment in useCallback with count as dependency -> Option A

4. Quick Check:

   Memoize functions with useCallback to avoid re-renders = A [OK]

Hint: Memoize event handlers with useCallback to prevent re-renders [OK]

Common Mistakes:

• Removing React.memo which disables optimization
• Moving function outside loses access to state
• Using useMemo incorrectly for functions

5. You want to optimize a component that receives a large list and a filter function as props. The filter function is defined inline in the parent component. Which approach best avoids unnecessary renders of the child component?

hard

A. Use useMemo to memoize the filtered list inside the child component

B. Define the filter function inline without memoization and rely on React.memo alone

C. Avoid React.memo and always re-render the child component to ensure fresh data

D. Wrap the child component with React.memo and memoize the filter function using useCallback with proper dependencies

Solution

1. Step 1: Understand props causing re-renders

   The inline filter function changes reference every render, causing child re-renders despite React.memo.

2. Step 2: Use React.memo and useCallback together

   Wrapping child with React.memo and memoizing the filter function with useCallback keeps function reference stable, avoiding unnecessary renders.

3. Final Answer:

   Wrap the child component with React.memo and memoize the filter function using useCallback with proper dependencies -> Option D

4. Quick Check:

   Memoize functions and use React.memo to optimize renders = A [OK]

Hint: Memoize functions and wrap child with React.memo for best optimization [OK]

Common Mistakes:

• Relying on React.memo without memoizing functions
• Memoizing filtered list inside child instead of function
• Avoiding React.memo and causing extra renders