Fallback UI patterns in React - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Suspense fallback UI display initially?

Consider this React component using Suspense with a fallback UI. What will the user see first when this component renders?

React

import React, { Suspense } from 'react';
const LazyComponent = React.lazy(() => import('./LazyComponent'));

export default function App() {
  return (
    <Suspense fallback={<div>Loading content...</div>}>
      <LazyComponent />
    </Suspense>
  );
}

A The text 'Loading content...' until LazyComponent finishes loading

B Nothing is shown until LazyComponent loads

C An error message is shown if LazyComponent fails to load

D The LazyComponent content appears immediately without fallback

💡 Hint

Think about what Suspense's fallback prop does while waiting for lazy components.

The fallback prop in Suspense shows the specified UI while the lazy component is loading. Here, it shows 'Loading content...'.

❓ state_output

intermediate

What is the output when ErrorBoundary catches an error?

Given this React component with an ErrorBoundary and fallback UI, what will be rendered if the child component throws an error?

React

import React, { Component } from 'react';

class ErrorBoundary extends Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false };
  }

  static getDerivedStateFromError(error) {
    return { hasError: true };
  }

  render() {
    if (this.state.hasError) {
      return <h1>Something went wrong.</h1>;
    }
    return this.props.children;
  }
}

function BuggyComponent() {
  throw new Error('Bug!');
}

export default function App() {
  return (
    <ErrorBoundary>
      <BuggyComponent />
    </ErrorBoundary>
  );
}

A The error message 'Bug!' is displayed on the screen

B The app crashes and shows a blank page

C Nothing is rendered because of the error

D <h1>Something went wrong.</h1>

💡 Hint

ErrorBoundary catches errors and shows fallback UI instead of crashing.

The ErrorBoundary catches errors in its children and renders the fallback UI <h1>Something went wrong.</h1> instead of crashing.

📝 Syntax

advanced

Which option correctly uses Suspense with a fallback UI?

Identify the correct syntax to use React Suspense with a fallback UI while loading a lazy component.

A <Suspense><LazyComp fallback={<div>Loading...</div>} /></Suspense>

B React.Suspense({ fallback: <div>Loading...</div> }, <LazyComp />)

C <Suspense fallback={<div>Loading...</div>}><LazyComp /></Suspense>

D <Suspense fallback={<div>Loading...</div>} /> <LazyComp />

💡 Hint

Suspense is a component that wraps children and takes fallback as a prop.

The correct syntax wraps the lazy component inside <Suspense fallback=...> and closes it after the children.

🔧 Debug

advanced

Why does this fallback UI never show?

This React code uses Suspense with a fallback, but the fallback UI never appears even though the lazy component takes time to load. Why?

React

import React, { Suspense } from 'react';
const LazyComp = React.lazy(() => import('./LazyComp'));

export default function App() {
  return (
    <div>
      <LazyComp />
      <Suspense fallback={<div>Loading...</div>} />
    </div>
  );
}

A Suspense must wrap the lazy component; here it is separate, so fallback never triggers

B LazyComp is not lazy loaded properly, so fallback is skipped

C Fallback UI only shows on errors, not loading

D Suspense fallback must be a string, not a React element

💡 Hint

Check how Suspense and lazy components are nested.

Suspense must wrap the lazy component to catch its loading state. Here, Suspense is separate, so fallback UI never shows.

🧠 Conceptual

expert

What is the main benefit of using fallback UI patterns in React?

Why do React developers use fallback UI patterns like Suspense fallback or ErrorBoundary fallback in their apps?

A To automatically retry loading components multiple times without user action

B To improve user experience by showing meaningful UI during loading or errors instead of blank or broken screens

C To reduce the bundle size by removing components that fail to load

D To prevent React from rendering any UI until all components are fully loaded

💡 Hint

Think about what users see when parts of the app are slow or broken.

Fallback UI patterns help keep the app responsive and friendly by showing loading messages or error notices instead of blank or crashed screens.

Practice

1. What is the main purpose of a fallback UI in React applications?

easy

A. To speed up the rendering of all components

B. To permanently replace the main UI with a different design

C. To disable user interactions during loading

D. To show a temporary interface while content is loading or an error occurs

Solution

1. Step 1: Understand fallback UI role

   Fallback UI is used to improve user experience by showing temporary content during loading or errors.

2. Step 2: Differentiate from permanent UI changes

   Fallback UI is temporary, not a permanent replacement or disabling interaction.

3. Final Answer:

   To show a temporary interface while content is loading or an error occurs -> Option D

4. Quick Check:

   Fallback UI = temporary loading/error display [OK]

Hint: Fallback UI shows temporary content during loading/errors [OK]

Common Mistakes:

• Thinking fallback UI is permanent
• Confusing fallback UI with performance optimization
• Assuming fallback UI disables all user actions

2. Which of the following is the correct way to render a fallback UI in React using conditional rendering?

easy

A. {isLoading ? <LoadingSpinner /> : <Content />}

B. {isLoading && <Content />}

C. {isLoading || <LoadingSpinner />}

D. {isLoading = <LoadingSpinner />}

Solution

1. Step 1: Review conditional rendering syntax

   Using the ternary operator ? : correctly chooses between fallback and main UI.

2. Step 2: Check each option's logic

   {isLoading ? <LoadingSpinner /> : <Content />} uses ternary correctly; B and C misuse logical operators; D uses assignment instead of comparison.

3. Final Answer:

   {isLoading ? <LoadingSpinner /> : <Content />} -> Option A

4. Quick Check:

   Ternary operator for fallback UI = {isLoading ? <LoadingSpinner /> : <Content />} [OK]

Hint: Use ternary operator for fallback UI rendering [OK]

Common Mistakes:

• Using && or || incorrectly for fallback UI
• Using assignment (=) instead of comparison
• Not providing both fallback and main UI in conditional

3. Given the code below, what will be rendered when hasError is true?

function MyComponent({ hasError, isLoading }) {
  if (hasError) {
    return <div>Error occurred</div>
  }
  if (isLoading) {
    return <div>Loading...</div>
  }
  return <div>Content loaded</div>
}

medium

A. Loading...

B. Error occurred

C. Content loaded

D. Nothing will render

Solution

1. Step 1: Check error condition first

   The component returns the error message immediately if hasError is true.

2. Step 2: Understand conditional order

   Since error check comes before loading, loading state is ignored if error exists.

3. Final Answer:

   <div>Error occurred</div> -> Option B

4. Quick Check:

   Error condition renders error UI first [OK]

Hint: Error check before loading shows error UI first [OK]

Common Mistakes:

• Assuming loading shows even if error is true
• Ignoring order of conditions
• Thinking content loads despite error

4. Identify the error in this fallback UI pattern code:

function Profile({ user }) {
  return (
    <div>
      {user ? <ProfileDetails user={user} /> : <LoadingSpinner />}
      {!user && <LoadingSpinner />}
    </div>
  )
}

medium

A. The conditional rendering syntax is invalid

B. The component will crash because user is undefined

C. The fallback UI <LoadingSpinner /> is shown twice when user is null

D. The fallback UI is missing for loading state

Solution

1. Step 1: Analyze conditional rendering logic

   The first condition shows LoadingSpinner if user is falsy.

2. Step 2: Check second condition

   The second condition shows LoadingSpinner if user is falsy, causing it to appear twice when user is falsy.

3. Final Answer:

   The fallback UI <LoadingSpinner /> is shown twice when user is null -> Option C

4. Quick Check:

   Duplicate fallback UI rendering due to conflicting conditions [OK]

Hint: Check if fallback UI appears more than once [OK]

Common Mistakes:

• Assuming fallback UI shows only once
• Confusing truthy and falsy conditions
• Ignoring duplicated components in render

5. You want to create a fallback UI that shows a spinner while data loads, an error message if loading fails, and the content once loaded. Which React pattern best handles this cleanly and accessibly?

hard

A. Use separate components for Loading, Error, and Content, and conditionally render them in order

B. Use nested ternary operators inside JSX to handle loading, error, and content states

C. Render all three components simultaneously and hide/show with CSS

D. Use a single state variable with string values and switch-case inside JSX

Solution

1. Step 1: Evaluate clarity and accessibility

   Separate components for each state improve readability and accessibility.

2. Step 2: Compare with other options

   Nested ternaries (B) reduce readability; rendering all simultaneously (C) wastes resources; switch-case in JSX (D) is less common and can be confusing.

3. Final Answer:

   Use separate components for Loading, Error, and Content, and conditionally render them in order -> Option A

4. Quick Check:

   Separate components for fallback states = Use separate components for Loading, Error, and Content, and conditionally render them in order [OK]

Hint: Separate components for each state improve clarity [OK]

Common Mistakes:

• Using nested ternaries that are hard to read
• Rendering all states at once and hiding with CSS
• Using complex switch-case inside JSX