Callback functions for state updates in React - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to update state using a callback function.

React

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

function increment() {
  setCount([1]);
}

Drag options to blanks, or click blank then click option'

Aprev => prev + 1

Bcount + 1

Ccount++

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using the current state variable directly can cause stale updates.

Trying to increment with 'count++' does not work in React state updates.

Using a callback function with setCount ensures you get the latest state value when updating.

2fill in blank

medium

Complete the code to toggle a boolean state using a callback function.

React

const [isOn, setIsOn] = useState(false);

function toggle() {
  setIsOn([1]);
}

Drag options to blanks, or click blank then click option'

AisOn = !isOn

Btrue

Cprev => !prev

D!isOn

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!isOn' directly can cause issues if state updates are batched.

Trying to assign a new value to 'isOn' directly is not allowed.

The callback function receives the previous state and returns its opposite, toggling the boolean correctly.

3fill in blank

hard

Fix the error in updating a counter state multiple times in a row.

React

const [counter, setCounter] = useState(0);

function increaseTwice() {
  setCounter([1]);
  setCounter([1]);
}

Drag options to blanks, or click blank then click option'

Acounter + 1

Bprev => prev + 1

Ccounter++

Dcounter += 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'counter + 1' twice only increments once due to stale state.

Trying to increment with 'counter++' or 'counter += 1' causes errors.

Using the callback form ensures each update uses the latest state, so calling twice increments by two.

4fill in blank

hard

Fill both blanks to update state with a callback and log the new value.

React

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

function updateAndLog() {
  setValue([1]);
  console.log([2]);
}

Drag options to blanks, or click blank then click option'

Aprev => prev + 5

Bvalue

Cprev + 5

Dvalue + 5

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to log the updated state immediately after setState shows old value.

Using 'prev + 5' directly without a function causes errors.

Use a callback to update state safely, and log the current state variable (which is still the old value immediately after setState).

5fill in blank

hard

Fill all three blanks to update a list state by adding a new item using a callback.

React

const [items, setItems] = useState([]);

function addItem(newItem) {
  setItems([1] => [...[2], [3]]);
}

Drag options to blanks, or click blank then click option'

AprevItems

CnewItem

Ditems

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'items' directly instead of previous state can cause stale updates.

Not spreading previous items results in overwriting the list.

The callback receives previous items, spreads them into a new array, and adds the new item at the end.

Practice

1. Why should you use a callback function when updating state in React with useState?

easy

A. Because it safely uses the previous state value to calculate the new state.

B. Because it makes the component render twice automatically.

C. Because it prevents the component from updating.

D. Because it allows you to update multiple states at once.

Solution

1. Step 1: Understand state updates in React

   State updates can be asynchronous, so relying on the current state value directly can cause bugs.

2. Step 2: Use callback function to access previous state

   The callback function receives the previous state safely and returns the new state, ensuring correct updates.

3. Final Answer:

   Because it safely uses the previous state value to calculate the new state. -> Option A

4. Quick Check:

   Callback uses previous state = safe update [OK]

Hint: Use callback to get previous state safely for updates [OK]

Common Mistakes:

• Updating state directly without callback causes stale values
• Thinking callback triggers extra renders
• Believing callback merges multiple states automatically

2. Which of the following is the correct syntax to update state using a callback function with useState?

easy

A. setCount(count + 1);

B. setCount(prevCount => prevCount + 1);

C. setCount(() => count + 1);

D. setCount(prevCount + 1);

Solution

1. Step 1: Identify correct callback syntax

   The callback function receives previous state as an argument and returns the new state.

2. Step 2: Check each option

   setCount(prevCount => prevCount + 1); uses prevCount => prevCount + 1, which is the correct callback form.

3. Final Answer:

   setCount(prevCount => prevCount + 1); -> Option B

4. Quick Check:

   Callback syntax = setState(prev => new) [OK]

Hint: Callback syntax always uses previous state parameter [OK]

Common Mistakes:

• Passing new state directly without function
• Using arrow function without parameter
• Trying to add number outside callback

3. What will be the output after clicking the button twice in this React component?

function Counter() {
  const [count, setCount] = React.useState(0);
  function increment() {
    setCount(prev => prev + 1);
  }
  return (
    <button onClick={increment}>Count: {count}</button>
  );
}

medium

A. Count: 2

B. Count: NaN

C. Count: 0

D. Count: 1

Solution

1. Step 1: Understand initial state and increment function

   Initial count is 0. Each click calls increment which updates state by adding 1 to previous count.

2. Step 2: Calculate state after two clicks

   First click: 0 + 1 = 1. Second click: 1 + 1 = 2.

3. Final Answer:

   Count: 2 -> Option A

4. Quick Check:

   Two increments = count 2 [OK]

Hint: Each click adds 1 to previous count using callback [OK]

Common Mistakes:

• Assuming state updates are batched incorrectly
• Using stale count value without callback
• Expecting count to reset after each click

4. Identify the error in this React state update code:

const [value, setValue] = React.useState(0);
function update() {
  setValue(value + 1);
  setValue(value + 1);
}

medium

A. setValue cannot be called twice in one function.

B. Syntax error: missing callback function.

C. State updates will be batched and only increase by 1, not 2.

D. State will reset to 0 after update.

Solution

1. Step 1: Analyze multiple state updates with direct value

   Both calls use the same stale value (0), so both set to 1.

2. Step 2: Understand batching behavior

   React batches updates, so final state is 1, not 2.

3. Final Answer:

   State updates will be batched and only increase by 1, not 2. -> Option C

4. Quick Check:

   Direct state updates = stale value, batched result [OK]

Hint: Multiple direct updates use stale state, use callback instead [OK]

Common Mistakes:

• Thinking setValue calls add up automatically
• Believing syntax error occurs without callback
• Assuming state resets unexpectedly

5. You want to toggle a boolean state isOpen in React. Which is the best way to update it safely when the new state depends on the old state?

hard

A. setIsOpen(false);

B. setIsOpen(!isOpen);

C. setIsOpen(true);

D. setIsOpen(prev => !prev);

Solution

1. Step 1: Understand toggling boolean state

   Toggling means switching from true to false or false to true based on previous state.

2. Step 2: Choose callback to avoid stale state

   Using prev => !prev ensures the toggle uses the latest state safely.

3. Final Answer:

   setIsOpen(prev => !prev); -> Option D

4. Quick Check:

   Toggle boolean safely = callback with previous state [OK]

Hint: Toggle booleans with callback using previous state [OK]

Common Mistakes:

• Using direct negation causes stale state bugs
• Setting fixed true or false instead of toggling
• Not using callback for dependent state updates