Updating phase in React - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output after clicking the button once?

Consider this React component that updates a counter on button clicks. What will be the displayed count after clicking the button once?

React

import React, { useState } from 'react';

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

  function handleClick() {
    setCount(count + 1);
    setCount(count + 1);
  }

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={handleClick}>Increment Twice</button>
    </div>
  );
}

export default Counter;

A Count: 1

B Count: 2

C Count: 0

D Count: NaN

💡 Hint

Remember that state updates in React are asynchronous and may be batched.

Both setCount calls use the same stale value of count (which is 0). So the state is set to 1 twice, resulting in a final count of 1, not 2.

❓ lifecycle

intermediate

Which hook runs after every update including the first render?

In React functional components, which hook runs after every render including the first render and all updates?

A useEffect with empty dependency array []

B useMemo

C useEffect with no dependency array

D useCallback

💡 Hint

Think about which hook runs after every render regardless of dependencies.

useEffect without a dependency array runs after every render, including the first and all updates.

📝 Syntax

advanced

What error does this React code produce on update?

What error will this React component produce when the button is clicked?

React

import React, { useState } from 'react';

function Example() {
  const [value, setValue] = useState(0);

  function handleClick() {
    setValue(value + 1);
    setValue(value + 1);
  }

  return (
    <div>
      <p>{value}</p>
      <button onClick={handleClick}>Update</button>
    </div>
  );
}

export default Example;

A No error, value updates to 3

B No error, value updates to 2

C Warning: Cannot update state during render

D No error, value updates to 1

💡 Hint

Consider how React batches state updates with the same value source.

Both setValue calls use the same stale value (0), so the final state is 1, not 3 or 2.

🔧 Debug

advanced

Why does this component not re-render after state update?

This React component updates state but does not re-render. Why?

React

import React, { useState } from 'react';

function NoRender() {
  const [obj, setObj] = useState({ count: 0 });

  function increment() {
    obj.count += 1;
    setObj(obj);
  }

  return (
    <div>
      <p>{obj.count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
}

export default NoRender;

A Syntax error in setObj call

B React does not detect change because the object reference is the same

C State updates asynchronously so render is delayed

D Button onClick handler is not attached

💡 Hint

Think about how React compares previous and new state values.

React uses shallow comparison for state. Since the object reference does not change, React skips re-render.

🧠 Conceptual

expert

What is the correct order of React updating phase steps?

Arrange the steps React follows during the updating phase after a state change.

A 1,3,2,4

B 1,2,3,4

C 3,1,2,4

D 2,1,3,4

💡 Hint

Think about React's render and commit phases and when effects run.

React first renders the component (1), then compares the new JSX with the old (3), then commits changes to the DOM (2), and finally runs effects (4).

Practice

1. What happens during the updating phase in a React component?

easy

A. The component is removed from the screen

B. The component is created for the first time

C. The component's styles are applied

D. The component re-renders when state or props change

Solution

1. Step 1: Understand React component lifecycle phases

   The updating phase happens after the initial render when state or props change.

2. Step 2: Identify what triggers re-rendering

   State or props changes cause React to re-render the component to update the UI.

3. Final Answer:

   The component re-renders when state or props change -> Option D

4. Quick Check:

   Updating phase = re-render on state/props change [OK]

Hint: Updating phase means re-render on state or props change [OK]

Common Mistakes:

• Confusing updating with mounting or unmounting phases
• Thinking styles apply only during updating
• Believing updating happens without state or props change

2. Which of the following is the correct way to update state in a React functional component during the updating phase?

easy

A. this.setState({ count: count + 1 })

B. setCount(count + 1)

C. updateState(count + 1)

D. changeState({ count: count + 1 })

Solution

1. Step 1: Identify state update method in functional components

   Functional components use the setter function from useState, e.g., setCount.

2. Step 2: Check syntax correctness

   setCount(count + 1) correctly updates the state by adding 1.

3. Final Answer:

   setCount(count + 1) -> Option B

4. Quick Check:

   Use setter from useState to update state [OK]

Hint: Use setter from useState to update state [OK]

Common Mistakes:

• Using this.setState in functional components
• Calling non-existent functions like updateState
• Trying to mutate state directly

3. Consider this React component snippet:

const [count, setCount] = useState(0);

useEffect(() => {
  console.log('Count changed:', count);
}, [count]);

setCount(1);
setCount(2);

What will be logged to the console after these updates?

medium

A. Count changed: 1Count changed: 2

B. No output

C. Count changed: 2

D. Count changed: 0Count changed: 1Count changed: 2

Solution

1. Step 1: Understand state updates batching

   Multiple state updates in the same event batch are combined; only the last update triggers effect.

2. Step 2: Analyze useEffect dependency

   useEffect runs after render when count changes, so it logs only once with the final value 2.

3. Final Answer:

   Count changed: 2 -> Option C

4. Quick Check:

   State updates batch; effect logs last value [OK]

Hint: Multiple state updates batch; effect runs once with last value [OK]

Common Mistakes:

• Assuming useEffect runs after every setCount call immediately
• Expecting console to log intermediate values
• Not knowing React batches state updates

4. What is wrong with this React code snippet during the updating phase?

const [count, setCount] = useState(0);

function increment() {
  count = count + 1;
  setCount(count);
}

medium

A. Directly modifying state variable instead of using setter

B. Missing dependency array in useEffect

C. Using setCount with a number instead of an object

D. Not returning JSX from the component

Solution

1. Step 1: Identify state mutation

   The code directly changes count variable, which is not allowed in React state management.

2. Step 2: Correct way to update state

   Use setCount(count + 1) without modifying count directly.

3. Final Answer:

   Directly modifying state variable instead of using setter -> Option A

4. Quick Check:

   Never mutate state variable directly; use setter [OK]

Hint: Never assign state variable directly; always use setter [OK]

Common Mistakes:

• Trying to change state variable directly
• Confusing state variable with setter function
• Ignoring React's immutable state rule

5. You want to update a React component's state only when a prop value changes, avoiding unnecessary re-renders. Which approach correctly uses the updating phase to achieve this?

function MyComponent({ value }) {
  const [state, setState] = useState(value);

  // What should go here?
}

hard

A. useEffect(() => { setState(value); }, [value]);

B. useEffect(() => { setState(value); }, []);

C. setState(value); // directly in component body

D. useEffect(() => { setState(value); });

Solution

1. Step 1: Use useEffect to react to prop changes

   To update state only when value prop changes, use useEffect with [value] dependency.

2. Step 2: Avoid unnecessary updates

   Dependency array ensures effect runs only when value changes, preventing infinite loops or extra renders.

3. Final Answer:

   useEffect(() => { setState(value); }, [value]); -> Option A

4. Quick Check:

   useEffect with [value] updates state on prop change only [OK]

Hint: Use useEffect with dependency array for prop-based updates [OK]

Common Mistakes:

• Leaving dependency array empty causing no updates
• Calling setState directly in component body causing infinite loops
• Omitting dependency array causing effect on every render