Parent-child data flow in React - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this React component?

Consider the following React components. What will be displayed on the screen?

React

import React, { useState } from 'react';

function Child({ message }) {
  return <p>{message}</p>;
}

export default function Parent() {
  const [msg] = useState('Hello from Parent');
  return <Child message={msg} />;
}

A Error: message is not defined

B undefined

C Hello from Parent

D Nothing is rendered

💡 Hint

Look at how the message prop is passed from Parent to Child.

The Parent component passes the msg state as a prop named message to the Child. The Child renders this prop inside a paragraph, so the output is the string 'Hello from Parent'.

❓ state_output

intermediate

What is the value of count after clicking the button once?

In this React component, what will be the value of count after the button is clicked once?

React

import React, { useState } from 'react';

function Child({ onClick }) {
  return <button onClick={onClick}>Click me</button>;
}

export default function Parent() {
  const [count, setCount] = useState(0);
  return <>
    <p>{count}</p>
    <Child onClick={() => setCount(count + 1)} />
  </>;
}

A NaN

B 1

C 0

D Error: setCount is not a function

💡 Hint

Check how the onClick function updates the state in the Parent.

The Parent component holds the count state starting at 0. The Child receives a function to increment count. Clicking the button calls this function, increasing count to 1.

🔧 Debug

advanced

Why does the Child component not update when Parent state changes?

Look at this React code. The Parent updates its state, but the Child does not show the new value. Why?

React

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

function Child({ value }) {
  return <p>{value}</p>;
}

export default function Parent() {
  const [count, setCount] = useState(0);
  const val = useMemo(() => count, []);
  return <>
    <button onClick={() => setCount(count + 1)}>Increment</button>
    <Child value={val} />
  </>;
}

A The Child component does not update because the button has no onClick handler.

B The Child component does not update because the 'value' prop is not passed correctly.

C The Child component does not update because 'setCount' is not called.

D The Child component does not update because the 'val' variable is not state and does not update.

💡 Hint

Think about what causes React components to re-render and memoized values to recompute.

Option D is correct. The val uses useMemo(() => count, []) with an empty dependency array, so it caches the initial count (0) and never recomputes. Parent re-renders on count change (re-rendering Child), but value={val} stays 0 since val is not state and doesn't update. Other options are incorrect: button has onClick, prop passed correctly, setCount called.

📝 Syntax

advanced

Which option correctly passes a callback from Parent to Child?

Which of these code snippets correctly passes a callback function from a Parent component to a Child component in React?

A function Parent() { const handleClick = () => alert('Clicked'); return <Child onClick={handleClick} />; }

B function Parent() { const handleClick = () => alert('Clicked'); return <Child onClick={handleClick()} />; }

C function Parent() { const handleClick = () => alert('Clicked'); return <Child onClick={handleClick} />(); }

D function Parent() { const handleClick = () => alert('Clicked'); return <Child onClick={() => handleClick} />; }

💡 Hint

Remember to pass the function itself, not the result of calling it.

Option A passes the function handleClick as a prop correctly. Option A calls the function immediately and passes its result (undefined). Option A tries to call the JSX element, which is invalid. Option A passes a function that returns the function, not the function itself, so the Child's onClick will not behave as expected.

🧠 Conceptual

expert

What is the best way to update Parent state from Child in React?

You want a Child component to update the Parent's state. Which approach follows React's recommended pattern?

A Pass a state setter function from Parent to Child as a prop, then call it inside Child.

B Have Child directly modify Parent's state variable using a global variable.

C Use React's Context API to let Child update Parent's state without props.

D Use a ref in Child to access and change Parent's state variable directly.

💡 Hint

Think about how React encourages data flow and state management.

React recommends passing state setter functions down as props to children that need to update parent state. Direct modification or refs break React's data flow and can cause bugs. Context is for sharing data but not for direct state updates.

Practice

1. In React, how does a parent component send data to its child component?

easy

A. By importing the child's variables

B. By passing data as props to the child component

C. By using the child's setState method

D. By directly modifying the child's state

Solution

1. Step 1: Understand data flow in React

   React uses one-way data flow where parents send data down to children.

2. Step 2: Identify how data is passed

   Parents pass data to children using props, which are like function arguments.

3. Final Answer:

   By passing data as props to the child component -> Option B

4. Quick Check:

   Parent to child data flow = props [OK]

Hint: Remember: props flow down from parent to child [OK]

Common Mistakes:

• Trying to change child's state directly from parent
• Using child's setState from parent
• Importing child's variables instead of passing props

2. Which of the following is the correct syntax to pass a prop named title with value "Hello" from a parent to a child component Child?

easy

A. <Child>title="Hello"</Child>

B. <Child {title: "Hello"} />

C. <Child title="Hello" />

D. <Child>{title: "Hello"}</Child>

Solution

1. Step 1: Recall JSX prop syntax

   Props are passed as attributes inside the component tag, like HTML attributes.

2. Step 2: Match correct syntax

   The correct way is <Child title="Hello" /> which sets prop title to "Hello".

3. Final Answer:

   <Child title="Hello" /> -> Option C

4. Quick Check:

   Props look like HTML attributes [OK]

Hint: Props look like HTML attributes inside component tags [OK]

Common Mistakes:

• Using object syntax inside JSX tags
• Placing props inside children instead of attributes
• Using curly braces incorrectly for props

3. Given the code below, what will be rendered inside the <Child /> component?

function Parent() {
  const message = "Hi there!";
  return <Child text={message} />;
}

function Child(props) {
  return <h1>{props.text}</h1>;
}

medium

A. Hi there!

B. text

C. {message}

D. Nothing will render

Solution

1. Step 1: Identify prop passed from Parent

   Parent passes prop named text with value "Hi there!" to Child.

2. Step 2: Check Child rendering

   Child renders <h1> with content from props.text, which is "Hi there!".

3. Final Answer:

   <h1>Hi there!</h1> -> Option A

4. Quick Check:

   props.text = "Hi there!" renders inside <h1> [OK]

Hint: Child renders what parent sends via props [OK]

Common Mistakes:

• Confusing prop name with string literal
• Expecting variable name to render instead of value
• Thinking nothing renders without explicit return

4. What is wrong with the following code that tries to pass data from parent to child?

function Parent() {
  const data = "Hello";
  return <Child data=data />;
}

function Child(props) {
  return <div>{props.data}</div>;
}

medium

A. Parent should use state instead of variable

B. Child component cannot receive props named data

C. Child must destructure props before use

D. The prop value should be inside curly braces: data={data}

Solution

1. Step 1: Check JSX prop syntax

   In JSX, to pass a JavaScript variable as prop value, use curly braces.

2. Step 2: Identify error in code

   Code uses data=data without braces, so it passes string "data" instead of variable value.

3. Final Answer:

   The prop value should be inside curly braces: data={data} -> Option D

4. Quick Check:

   JSX props need curly braces for variables [OK]

Hint: Use curly braces to pass variables as props [OK]

Common Mistakes:

• Omitting curly braces around variables in JSX props
• Thinking child cannot receive certain prop names
• Believing state is required to pass props

5. You want to pass a list of items from a parent to a child component and render them as a list. Which approach correctly implements this parent-child data flow?

function Parent() {
  const items = ["Apple", "Banana", "Cherry"];
  return <Child items={items} />;
}

function Child(props) {
  return (
    <ul>
      {props.items.map((item, index) => (
        <li key={index}>{item}</li>
      ))}
    </ul>
  );
}

hard

A. This code correctly passes the list and renders it in the child

B. The parent should convert the list to a string before passing

C. Child should not use map; it should render items directly

D. Key prop is not needed when rendering lists

Solution

1. Step 1: Check how data is passed

   Parent passes array items as prop named items using curly braces, which is correct.

2. Step 2: Check child rendering

   Child uses map to create <li> elements for each item with unique key, which is best practice.

3. Final Answer:

   This code correctly passes the list and renders it in the child -> Option A

4. Quick Check:

   Array props + map in child = correct list rendering [OK]

Hint: Pass arrays as props and map in child to render lists [OK]

Common Mistakes:

• Passing arrays as strings instead of arrays
• Not using keys when rendering lists
• Trying to render arrays directly without map