Avoiding unnecessary renders in React - Step-by-Step Execution

Concept Flow - Avoiding unnecessary renders

Initial Render

↓

Component Renders

↓

State or Props Change?

No→No Re-render

Yes↓

Check if Render Needed

↓

Render or Skip

↓

Update DOM if Rendered

↓

Wait for Next Change

This flow shows how React decides to re-render a component only when state or props change meaningfully, avoiding unnecessary updates.

Execution Sample

React

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

const Child = memo(({ count }) => {
  console.log('Child render');
  return <div>Count: {count}</div>;
});

export default function App() {
  const [count, setCount] = useState(0);
  const [text, setText] = useState('');

  return (
    <>
      <Child count={count} />
      <button onClick={() => setCount(count + 1)}>Increment</button>
      <input value={text} onChange={e => setText(e.target.value)} />
    </>
  );
}

This React code shows a memoized Child component that only re-renders when its count prop changes, avoiding re-renders when unrelated state changes.

Execution Table

Step	Action	State Before	State After	Child Render?	Console Output
1	Initial render	count=0, text=''	count=0, text=''	Yes	Child render
2	Click Increment button	count=0, text=''	count=1, text=''	Yes	Child render
3	Type in input (text='a')	count=1, text=''	count=1, text='a'	No
4	Type in input (text='ab')	count=1, text='a'	count=1, text='ab'	No
5	Click Increment button	count=1, text='ab'	count=2, text='ab'	Yes	Child render
6	No further actions	count=2, text='ab'	count=2, text='ab'	No

💡 No re-render occurs when unrelated state (text) changes because Child is memoized and count prop did not change.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
count	0	0	1	1	1	2	2
text	''	''	''	'a'	'ab'	'ab'	'ab'

Key Moments - 3 Insights

Why doesn't the Child component re-render when I type in the input?

Because Child is wrapped with React.memo and only depends on the count prop, which did not change during input typing (see steps 3 and 4 in execution_table).

What triggers the Child component to re-render?

Changing the count state triggers Child to re-render because count is passed as a prop to Child (see steps 2 and 5 in execution_table).

Does React re-render the whole App component when any state changes?

Yes, App re-renders on any state change, but memoized Child only re-renders if its props change, avoiding unnecessary DOM updates (see execution_table steps 3 and 4).

Visual Quiz - 3 Questions

Look at the execution table, at which step does the Child component NOT re-render despite state change?

A Step 5

B Step 3

C Step 2

D Step 1

💡 Hint

Check the 'Child Render?' column for steps where state changes but Child render is 'No'.

According to variable_tracker, what is the value of 'count' after step 5?

A 2

B 1

C 0

D 'ab'

💡 Hint

Look at the 'count' row under 'After 5' column in variable_tracker.

If the Child component was not memoized, what would happen when typing in the input?

A Child would only re-render on count change

B Child would never re-render

C Child would re-render on every input change

D App would not re-render

💡 Hint

Consider how React re-renders components by default without memoization (see key_moments about memo).

Concept Snapshot

Avoid unnecessary renders in React by memoizing components with React.memo.
Memoized components re-render only when their props change.
State changes in parent cause parent re-render but not memoized child if props unchanged.
Use memo to improve performance by skipping redundant renders.
Check console logs to verify when components render.

Full Transcript

This lesson shows how React avoids unnecessary renders using React.memo. The Child component is wrapped with memo, so it only re-renders when its count prop changes. When the input text changes, the Child does not re-render because its props remain the same. The execution table tracks each step: initial render, incrementing count, typing text, and shows when Child renders or skips rendering. The variable tracker shows how count and text state change over time. Key moments clarify why Child skips renders on text changes and re-renders on count changes. The quiz tests understanding of these behaviors. This helps beginners see how React optimizes rendering to improve app performance.

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