Why React is used - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does React use a virtual DOM?

React uses a virtual DOM to improve performance. What does the virtual DOM do?

A It updates the real DOM directly every time a change happens.

B It removes the real DOM and uses only JavaScript objects.

C It creates a copy of the real DOM to find changes before updating the real DOM.

D It delays all updates until the user refreshes the page.

💡 Hint

Think about how React makes updates faster without changing the whole page.

React creates a virtual DOM, which is a lightweight copy of the real DOM. It compares changes in the virtual DOM first, then updates only the parts of the real DOM that changed. This makes updates faster and smoother.

❓ component_behavior

intermediate

What happens when React state changes?

In React, when you update a component's state using useState, what happens next?

A React re-renders only the component with the updated state.

B Nothing happens until you manually refresh the page.

C React deletes the component and creates a new one from scratch.

D The entire page reloads to show the new state.

💡 Hint

Think about how React updates the UI efficiently when data changes.

When state changes, React re-renders the component that owns the state. It updates the UI to reflect the new state without reloading the whole page.

📝 Syntax

advanced

Which React hook is used to perform side effects?

You want to run code after a React component renders, like fetching data. Which hook should you use?

A useEffect

B useState

C useMemo

D useCallback

💡 Hint

This hook runs after rendering and can watch for changes.

useEffect runs side effects after rendering, such as fetching data or updating the document title.

🔧 Debug

advanced

Why does this React component not update on button click?

Look at this React component code. Why does clicking the button not update the displayed count? function Counter() { let count = 0; return (

Count: {count}

); }

React

function Counter() {
  let count = 0;
  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => { count += 1; }}>Increase</button>
    </div>
  );
}

A The button's onClick handler syntax is incorrect and causes an error.

B The count variable is not a state, so React does not re-render when it changes.

C The count variable is declared with let instead of const, causing a syntax error.

D React components cannot have variables inside the function body.

💡 Hint

React only re-renders when state or props change.

The count variable is a normal variable that resets on every render. React does not track it as state, so changes to it do not cause re-rendering.

❓ lifecycle

expert

When does React run cleanup functions in useEffect?

Consider this React useEffect hook: useEffect(() => { const id = setInterval(() => console.log('tick'), 1000); return () => clearInterval(id); }, []); When is the cleanup function called?

React

useEffect(() => {
  const id = setInterval(() => console.log('tick'), 1000);
  return () => clearInterval(id);
}, []);

A Never, because the dependency array is empty.

B Every time the component re-renders, before running the effect again.

C Immediately after the effect runs for the first time.

D Only when the component unmounts from the page.

💡 Hint

Think about when React cleans up effects with empty dependency arrays.

With an empty dependency array, the effect runs once on mount, and the cleanup runs only when the component unmounts.

Practice

1. Why do developers use React for building websites?

easy

A. To design database schemas

B. To write backend server code easily

C. To manage network security settings

D. To create reusable components that make development faster

Solution

1. Step 1: Understand React's main feature

   React breaks websites into small, reusable parts called components, which helps developers build faster and maintainable code.

2. Step 2: Compare options with React's purpose

   Only To create reusable components that make development faster describes creating reusable components, which is React's core use. Other options relate to backend, database, or security, which React does not handle.

3. Final Answer:

   To create reusable components that make development faster -> Option D

4. Quick Check:

   Reusable components = C [OK]

Hint: React is mainly for building UI components fast [OK]

Common Mistakes:

• Confusing React with backend frameworks
• Thinking React manages databases
• Assuming React handles security

2. Which of the following is the correct way to define a React functional component?

easy

A. component MyComponent() { return Hello; }

B. function MyComponent() { return Hello; }

C. def MyComponent() { return Hello; }

D. func MyComponent() { return Hello; }

Solution

1. Step 1: Recall React functional component syntax

   React functional components are JavaScript functions that return JSX, defined using the keyword 'function'.

2. Step 2: Check each option's syntax

   function MyComponent() { return
   Hello; } uses 'function' correctly. Options B, C, and D use invalid keywords not recognized in JavaScript or React.

3. Final Answer:

   function MyComponent() { return <div>Hello</div>; } -> Option B

4. Quick Check:

   React components use 'function' keyword [OK]

Hint: React components start with 'function' keyword [OK]

Common Mistakes:

• Using Python or other language keywords
• Confusing component declaration syntax
• Omitting return statement or JSX

3. What will be the result of this React component rendering?

function Greeting() {
  const name = 'Alice';
  return <h1>Hello, {name}!</h1>;
}

medium

A. Syntax Error

B. Hello, {name}!

C. <h1>Hello, Alice!</h1>

D. <h1>Hello, name!</h1>

Solution

1. Step 1: Understand JSX expression embedding

   In JSX, curly braces { } embed JavaScript expressions. Here, {name} inserts the value of the variable 'name', which is 'Alice'.

2. Step 2: Predict rendered output

   The component returns an h1 element with text 'Hello, Alice!'. So the rendered HTML is <h1>Hello, Alice!</h1>.

3. Final Answer:

   <h1>Hello, Alice!</h1> -> Option C

4. Quick Check:

   JSX {name} inserts variable value [OK]

Hint: JSX uses { } to insert variables [OK]

Common Mistakes:

• Thinking {name} prints literally
• Confusing JSX with plain HTML
• Expecting syntax error for valid JSX

4. Identify the error in this React component code:

function Welcome() {
  return (
    <div>
      <h1>Welcome</h1>
      <p>Have a nice day!</p>
    </div>
  )
  console.log('Rendered');
}

medium

A. console.log is unreachable after return statement

B. Missing semicolon after return

C. JSX tags are not closed properly

D. Function name should be lowercase

Solution

1. Step 1: Analyze function flow

   The return statement ends the function execution, so any code after it is unreachable.

2. Step 2: Check the console.log placement

   console.log('Rendered') is after return, so it will never run, which is a logical error.

3. Final Answer:

   console.log is unreachable after return statement -> Option A

4. Quick Check:

   Code after return is unreachable [OK]

Hint: Code after return won't run [OK]

Common Mistakes:

• Ignoring unreachable code warnings
• Thinking semicolon is mandatory after return
• Assuming function names must be lowercase

5. How does React improve website speed when updating the user interface?

hard

A. By updating only the parts of the page that change using a virtual DOM

B. By reloading the entire page on every change

C. By using server-side rendering exclusively

D. By disabling user interactions during updates

Solution

1. Step 1: Understand React's update mechanism

   React uses a virtual DOM to track changes and updates only the parts of the real DOM that need to change, avoiding full page reloads.

2. Step 2: Compare options with React's behavior

   By updating only the parts of the page that change using a virtual DOM correctly describes this selective update process. Options B, C, and D describe incorrect or unrelated behaviors.

3. Final Answer:

   By updating only the parts of the page that change using a virtual DOM -> Option A

4. Quick Check:

   Virtual DOM updates only changed parts [OK]

Hint: React updates only changed parts for speed [OK]

Common Mistakes:

• Thinking React reloads whole page
• Confusing client and server rendering
• Assuming React disables interactions