Rendering lists in React - Performance & Optimization

Performance: Rendering lists in React

MEDIUM IMPACT

This affects how fast the page renders and updates when showing multiple items, impacting user interaction smoothness and load speed.

Rendering a list of items with React

React

const List = ({ items }) => items.map(item => <li key={item.id}>{item.name}</li>);

Using unique stable keys lets React update only changed items, minimizing re-renders.

📈 Performance GainReduces re-renders to changed items only, improving responsiveness and lowering CPU usage.

Rendering a list of items with React

React

const List = ({ items }) => items.map((item, index) => <li key={index}>{item}</li>);

Using array index as key causes React to re-render all items on changes, leading to inefficient updates.

📉 Performance CostTriggers re-render of entire list on item change, increasing CPU work and slowing interaction.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Index as key	High (all items updated)	Many (each update triggers layout)	High (repaints all items)	[X] Bad
Unique stable keys	Low (only changed items updated)	Few (minimal layout recalculations)	Low (paints only changed items)	[OK] Good
Render all large list	Very high (thousands of nodes)	Many (heavy layout)	Very high (large paint area)	[X] Bad
Virtualized list	Low (only visible nodes)	Few (small layout area)	Low (small paint area)	[OK] Good

Rendering Pipeline

React reconciles the list using keys to decide which DOM nodes to update, then browser recalculates styles, layouts, and paints only changed parts.

→Reconciliation

→Style Calculation

→Layout

→Paint

→Composite

⚠️ BottleneckReconciliation and Layout stages are most expensive when keys are unstable or list is large.

Core Web Vital Affected

INP

This affects how fast the page renders and updates when showing multiple items, impacting user interaction smoothness and load speed.

Optimization Tips

1Always use unique and stable keys for list items to minimize re-renders.

2Avoid rendering very large lists all at once; use virtualization libraries.

3Check React DevTools and browser Performance panel to spot expensive list updates.

Performance Quiz - 3 Questions

Why should you avoid using array index as key when rendering lists in React?

A It increases the bundle size significantly.

B It makes the list items invisible in the DOM.

C It causes React to re-render all items on any change, hurting performance.

D It disables React's event handling on list items.

DevTools: Performance

How to check: Record a profile while interacting with the list, then inspect the flame chart for long scripting or layout times during updates.

What to look for: Look for large blocks of scripting or layout time when list updates happen; fewer and shorter blocks indicate better performance.

Practice

1. What is the main purpose of using the map() method when rendering lists in React?

easy

A. To filter out unwanted items from the list

B. To sort the list items alphabetically

C. To transform an array of data into an array of React elements

D. To add styles to each list item

Solution

1. Step 1: Understand the role of map() in React

   The map() method is used to take an array of data and create a new array by transforming each item. In React, this means turning data into React elements.

2. Step 2: Identify what map() does in rendering lists

   When rendering lists, map() creates a React element for each item, which React can then display on the screen.

3. Final Answer:

   To transform an array of data into an array of React elements -> Option C

4. Quick Check:

   map() creates elements from data [OK]

Hint: Remember: map() turns data into elements [OK]

Common Mistakes:

• Thinking map() sorts or filters data
• Using map() without returning elements
• Confusing map() with forEach()

2. Which of the following is the correct way to add a unique key to list items in React?

easy

A. {items.map(item => <li key={item.id}>{item.name}</li>)}

B. {items.map(item => <li key={Math.random()}>{item.name}</li>)}

C. {items.map(item => <li key="index">{item.name}</li>)}

D. {items.map(item => <li>{item.name}</li>)}

Solution

1. Step 1: Understand the importance of keys in React lists

   Keys help React identify which items changed, added, or removed. They must be unique and stable for each list item.

2. Step 2: Evaluate each option for key usage

   {items.map(item => <li>{item.name}</li>)} has no key, so React will warn. {items.map(item => <li key={item.id}>{item.name}</li>)} uses a unique id from the item, which is correct. {items.map(item => <li key="index">{item.name}</li>)} uses a string 'index' for all keys, which is not unique. {items.map(item => <li key={Math.random()}>{item.name}</li>)} uses Math.random(), which changes every render and is unstable.

3. Final Answer:

   {items.map(item => <li key={item.id}>{item.name}</li>)} -> Option A

4. Quick Check:

   Unique stable keys = {items.map(item => <li key={item.id}>{item.name}</li>)} [OK]

Hint: Use unique stable keys from data, not random or fixed strings [OK]

Common Mistakes:

• Omitting the key prop entirely
• Using index or random values as keys
• Using non-unique keys causing rendering bugs

3. What will be the output of this React code snippet?

const fruits = ['Apple', 'Banana', 'Cherry'];

function FruitList() {
  return (
    <ul>
      {fruits.map((fruit, index) => <li key={index}>{fruit}</li>)}
    </ul>
  );
}

medium

A. SyntaxError due to missing keys

B. AppleBananaCherry

C. 012

D. Empty list rendered

Solution

1. Step 1: Understand the map function output

   The map() creates a list item for each fruit with the fruit name as content.

2. Step 2: Check the key usage and rendering

   Using index as key is allowed (though not ideal), so React renders the list with fruit names inside <li> tags.

3. Final Answer:

   <ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul> -> Option B

4. Quick Check:

   map() renders fruit names as list items [OK]

Hint: map() returns elements with content, keys don't affect output text [OK]

Common Mistakes:

• Confusing keys with displayed content
• Expecting errors from using index keys
• Thinking map returns indexes instead of values

4. Identify the error in this React list rendering code:

const numbers = [1, 2, 3];

function NumberList() {
  return (
    <ul>
      {numbers.map(number => <li>number</li>)}
    </ul>
  );
}

medium

A. Missing key prop on list items

B. numbers array is empty, so no output

C. Syntax error due to arrow function

D. The word 'number' is rendered literally, not the variable

Solution

1. Step 1: Analyze the JSX inside map

   The code writes <li>number</li> which renders the literal text 'number', not the variable value.

2. Step 2: Identify how to fix variable rendering

   To render the variable, it should be inside curly braces: <li>{number}</li>.

3. Final Answer:

   The word 'number' is rendered literally, not the variable -> Option D

4. Quick Check:

   JSX needs curly braces for variables [OK]

Hint: Use curly braces {} to render variables in JSX [OK]

Common Mistakes:

• Forgetting curly braces around variables
• Ignoring missing key warnings
• Assuming array is empty without checking

5. You have a list of user objects with possible duplicate IDs:

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 1, name: 'Carol' }
];

function UserList() {
  return (
    <ul>
      {users.map((user, index) => <li key={`${user.id}-${index}`}>{user.name}</li>)}
    </ul>
  );
}

What problem can occur and how to fix it?

hard

A. Duplicate keys cause rendering issues; use unique keys like index or combined values

B. No problem; React handles duplicate keys automatically

C. Syntax error due to duplicate IDs in objects

D. List will render only first two users ignoring duplicates

Solution

1. Step 1: Understand React's key requirement

   Keys must be unique to help React track items. Duplicate keys cause rendering bugs or warnings.

2. Step 2: Identify the duplicate key issue in code

   Two users share id=1, so keys are not unique. This can confuse React during updates.

3. Step 3: Suggest a fix for unique keys

   Use a unique key like combining id and index: key={`${user.id}-${index}`} or a unique identifier.

4. Final Answer:

   Duplicate keys cause rendering issues; use unique keys like index or combined values -> Option A

5. Quick Check:

   Unique keys prevent rendering bugs [OK]

Hint: Keys must be unique; combine id with index if duplicates exist [OK]

Common Mistakes:

• Ignoring duplicate keys causing UI bugs
• Assuming React auto-fixes duplicate keys
• Using only index keys without data context