Avoiding unnecessary renders in React - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when using React.memo?

Consider a React functional component wrapped with React.memo. What happens when its parent re-renders but the props remain the same?

React

const Child = React.memo(({ count }) => {
  console.log('Child rendered');
  return <div>{count}</div>;
});

function Parent() {
  const [count, setCount] = React.useState(0);
  const [other, setOther] = React.useState(0);

  return (
    <>
      <Child count={count} />
      <button onClick={() => setOther(other + 1)}>Change Other</button>
    </>
  );
}

A Child component renders only once initially; subsequent Parent re-renders with unchanged props do not cause Child to re-render.

B Child component never renders because React.memo prevents all renders.

C Child component re-renders every time Parent re-renders, logging 'Child rendered' each time.

D Child component re-renders only when the 'other' state changes.

💡 Hint

React.memo skips rendering if props are shallowly equal.

React.memo compares the previous and next props. If they are the same, it skips rendering the child component. Here, 'count' does not change when 'other' changes, so Child does not re-render.

❓ state_output

intermediate

What is the console output when using useCallback incorrectly?

Given the following React component, what will be logged when clicking the 'Increment' button multiple times?

React

function Counter() {
  const [count, setCount] = React.useState(0);

  const increment = React.useCallback(() => {
    setCount(count + 1);
    console.log('Count inside increment:', count);
  }, []);

  return <button onClick={increment}>Increment</button>;
}

A Always logs 'Count inside increment: 0' regardless of clicks.

B Logs undefined because count is not initialized.

C Throws an error because count is not in dependency array.

D Logs increasing count values: 0, 1, 2, 3, ... as button is clicked.

💡 Hint

Think about how useCallback dependencies affect captured variables.

The increment function captures the initial value of 'count' (which is 0) because the dependency array is empty. It never updates, so it always logs 0 and sets count to 1 on every click.

🔧 Debug

advanced

Why does this component re-render unnecessarily?

Examine the following React component. Why does the Child component re-render every time the Parent renders, even though props seem unchanged?

React

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

function Parent() {
  const [count, setCount] = React.useState(0);

  return (
    <>
      <Child onClick={() => setCount(count + 1)} />
      <p>{count}</p>
    </>
  );
}

A Because the Child component lacks a key prop.

B Because count state changes, Child must re-render regardless of props.

C Because React.memo does not work with arrow functions.

D Because the onClick prop is a new function on every render, React.memo sees it as changed and re-renders Child.

💡 Hint

Functions defined inside components are recreated on every render.

Each render creates a new arrow function for onClick, so React.memo detects a prop change and re-renders Child. To avoid this, use useCallback to memoize the function.

📝 Syntax

advanced

Which option correctly prevents unnecessary re-renders using useMemo?

You want to memoize a computed value that depends on 'items' array. Which code snippet correctly uses useMemo to avoid recomputing unless 'items' changes?

A const total = React.useMemo(() => items.reduce((a, b) => a + b, 0), []);

B const total = React.useMemo(() => items.reduce((a, b) => a + b, 0), [items]);

C const total = React.useMemo(items.reduce((a, b) => a + b, 0), [items]);

D const total = React.useMemo(() => items.reduce((a, b) => a + b, 0));

💡 Hint

useMemo expects a function and a dependency array.

Option B correctly passes a function and dependency array. Option B never updates total after initial render. Option B passes a value instead of a function, causing error. Option B misses dependency array, so recomputes every render.

🧠 Conceptual

expert

Which technique best avoids unnecessary renders in deeply nested React components?

You have a deeply nested component tree. Which approach most effectively prevents unnecessary renders of child components when unrelated state changes in ancestors?

A Lift state up to the top and pass all state as props to every child component.

B Use React Context to pass all state and update it frequently to keep children in sync.

C Use React.memo on child components and useContext selectively with useMemo or useCallback to avoid prop changes.

D Avoid using React.memo and rely on React's default reconciliation to optimize renders.

💡 Hint

Think about combining memoization and selective context usage.

Option C combines React.memo to prevent re-renders when props don't change, and selective useContext with memoized values to avoid unnecessary updates. This is the most effective approach for deep trees.

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