Loading states and error patterns in Angular - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What will this Angular component display during data loading?

Consider this Angular standalone component using signals to fetch data asynchronously. What will the user see while the data is loading?

Angular

import { Component, signal, effect } from '@angular/core';
import { inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Component({
  selector: 'app-loading-example',
  standalone: true,
  template: `
    <div *ngIf="loading()">Loading...</div>
    <div *ngIf="error()">Error occurred</div>
    <div *ngIf="!loading() && !error()">Data: {{ data() }}</div>
  `
})
export class LoadingExampleComponent {
  private http = inject(HttpClient);
  loading = signal(true);
  error = signal(false);
  data = signal('');

  constructor() {
    this.http.get<string>('https://api.example.com/data').subscribe({
      next: (res) => {
        this.data.set(res);
        this.loading.set(false);
      },
      error: () => {
        this.error.set(true);
        this.loading.set(false);
      }
    });
  }
}

A The component shows a blank screen until data arrives.

B The text 'Error occurred' is shown immediately and never changes.

C The data is displayed immediately without showing 'Loading...'.

D The text 'Loading...' is shown until data arrives, then the data is displayed.

💡 Hint

Look at the loading signal and how it controls the template display.

The component starts with loading set to true, so it shows 'Loading...'. When data arrives, loading becomes false and the data is shown. If an error occurs, 'Error occurred' is shown instead.

📝 Syntax

intermediate

Which option causes a syntax error in Angular template for loading state?

Identify the Angular template snippet that will cause a syntax error when used to show loading and error states.

Angular

<div *ngIf="loading">Loading...</div>
<div *ngIf="error">Error occurred</div>
<div *ngIf="!loading && !error">Content loaded</div>

A <div *ngIf="loading">Loading...</div>

B <div *ngIf="error">Error occurred</div>

C <div *ngIf="!loading && !error">Content loaded</div>

D <div *ngIf="loading || error">Loading or Error</div>

💡 Hint

Check the syntax for combining conditions inside *ngIf.

Angular templates do not support complex expressions with logical operators like && directly inside *ngIf. You must use a method or a signal that returns a boolean instead.

❓ state_output

advanced

What is the final value of the error signal after this code runs?

Given this Angular component code snippet, what is the value of error() after the HTTP request fails?

Angular

import { Component, signal } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { inject } from '@angular/core';

@Component({
  selector: 'app-error-test',
  standalone: true,
  template: `<div *ngIf="error()">Error!</div>`
})
export class ErrorTestComponent {
  private http = inject(HttpClient);
  error = signal(false);

  constructor() {
    this.http.get('https://api.example.com/fail').subscribe({
      next: () => this.error.set(false),
      error: () => this.error.set(true)
    });
  }
}

A false

B true

C undefined

D null

💡 Hint

Consider what happens in the error callback of the subscription.

The HTTP request fails, so the error callback runs and sets the error signal to true.

🔧 Debug

advanced

Why does this Angular component never show the loading message?

Review this Angular component code. The loading message never appears. What is the cause?

Angular

import { Component, signal } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { inject } from '@angular/core';

@Component({
  selector: 'app-debug-loading',
  standalone: true,
  template: `
    <div *ngIf="loading()">Loading...</div>
    <div *ngIf="!loading()">Loaded</div>
  `
})
export class DebugLoadingComponent {
  private http = inject(HttpClient);
  loading = signal(false);

  constructor() {
    this.http.get('https://api.example.com/data').subscribe(() => {
      this.loading.set(false);
    });
  }
}

A The loading signal is never set to true, so loading message never shows.

B The template syntax for *ngIf is incorrect and causes a silent failure.

C The HTTP request never completes, so loading stays false.

D The component is missing the OnInit lifecycle hook to start loading.

💡 Hint

Check the initial value of the loading signal and when it changes.

The loading signal starts as false and is never set to true, so the loading message never appears.

🧠 Conceptual

expert

Which pattern best handles loading and error states in Angular with signals?

Choose the best pattern to manage loading and error states in an Angular component using signals and HTTP requests.

A Use separate signals for loading and error, set loading true before request, false after, and error true on failure.

B Use a single signal that holds 'loading', 'error', or 'success' string states and switch template based on it.

C Use only the error signal and assume loading is false until error or data arrives.

D Use a boolean loading signal and ignore error states, showing data or loading only.

💡 Hint

Think about clarity and explicit state management for UI feedback.

Using separate signals for loading and error states is clear and allows the UI to show precise feedback. Setting loading true before the request and false after ensures correct loading display. Setting error true on failure allows error messages.

Practice

1. What is the main purpose of showing a loading state in an Angular component?

easy

A. To automatically refresh the page after loading

B. To hide the entire component until data is loaded

C. To disable all user interactions permanently

D. To inform the user that data is being fetched and they should wait

Solution

1. Step 1: Understand loading state purpose

   Loading states are used to show users that data is being fetched and they need to wait.

2. Step 2: Analyze options

   Only "To inform the user that data is being fetched and they should wait" correctly describes this purpose. The other options describe incorrect or unrelated behaviors.

3. Final Answer:

   To inform the user that data is being fetched and they should wait -> Option D

4. Quick Check:

   Loading state = Inform user to wait [OK]

Hint: Loading states tell users to wait, not hide or disable [OK]

Common Mistakes:

• Thinking loading hides the component completely
• Assuming loading refreshes the page
• Believing loading disables all interactions permanently

2. Which Angular syntax correctly shows a loading message only when isLoading signal is true?

easy

A. <div *ngIf="isLoading()">Loading...</div>

B. <div *ngIf="isLoading">Loading...</div>

C. <div *ngIf="isLoading = true">Loading...</div>

D. <div *ngIf="isLoading == false">Loading...</div>

Solution

1. Step 1: Understand Angular signals usage

   Signals are functions, so to get their value, you call them like isLoading().

2. Step 2: Check each option

   <div *ngIf="isLoading()">Loading...</div> correctly calls isLoading(). <div *ngIf="isLoading">Loading...</div> treats it as a property, which is incorrect for signals. <div *ngIf="isLoading = true">Loading...</div> uses assignment inside *ngIf, which is invalid. <div *ngIf="isLoading == false">Loading...</div> checks for false, which is opposite of loading.

3. Final Answer:

   <div *ngIf="isLoading()">Loading...</div> -> Option A

4. Quick Check:

   Call signals with () in *ngIf [OK]

Hint: Call signals as functions with () inside *ngIf [OK]

Common Mistakes:

• Using signal name without ()
• Trying to assign inside *ngIf
• Checking wrong boolean condition

3. Given this Angular template snippet:

<div *ngIf="error()" role="alert">Error: {{ error() }}</div>
<div *ngIf="isLoading()">Loading...</div>
<div *ngIf="!isLoading() && !error()">Data loaded</div>

What will be displayed if isLoading() returns false and error() returns "Network error"?

medium

A. Loading...

B. Error: Network error

C. Data loaded

D. Nothing is displayed

Solution

1. Step 1: Evaluate conditions with given values

   isLoading() is false, error() is "Network error" (truthy).

2. Step 2: Check which *ngIf blocks show

   The first div shows if error() is truthy, so it displays "Error: Network error". The second div shows if isLoading() is true (false here), so no. The third div shows if not loading and no error, but error exists, so no.

3. Final Answer:

   Error: Network error -> Option B

4. Quick Check:

   Error present = show error message [OK]

Hint: Error message shows if error() is truthy, regardless of loading [OK]

Common Mistakes:

• Ignoring error() and showing loading
• Showing data loaded despite error
• Assuming nothing shows when error exists

4. Identify the error in this Angular component code snippet handling loading and error states:

export class DataComponent {
  isLoading = signal(false);
  error = signal(null);

  fetchData() {
    this.isLoading = true;
    fetch('/api/data')
      .then(() => this.isLoading = false)
      .catch(err => this.error = err.message);
  }
}

medium

A. fetchData does not set error to null before fetching

B. Missing async keyword on fetchData method

C. Signals are reassigned instead of updating their value

D. No return statement in fetchData

Solution

1. Step 1: Understand how to update signals

   Signals are objects with a method to update their value, not variables to reassign.

2. Step 2: Check code for signal updates

   The code does this.isLoading = true which reassigns the signal variable instead of calling this.isLoading.set(true). Same for error.

3. Final Answer:

   Signals are reassigned instead of updating their value -> Option C

4. Quick Check:

   Update signals with .set(), not reassignment [OK]

Hint: Use .set() to update signals, not direct assignment [OK]

Common Mistakes:

• Assigning signals directly instead of using .set()
• Forgetting to reset error before fetch
• Assuming async needed without await

5. You want to show a loading spinner while data loads, an error message if loading fails, and the data content otherwise. Which Angular template pattern correctly handles these states using signals isLoading(), error(), and data()?

hard

A. <div *ngIf="isLoading()">Loading spinner...</div>
<div *ngIf="error()" role="alert">Error: {{ error() }}</div>
<div *ngIf="!isLoading() && !error()">{{ data() }}</div>

B. <div *ngIf="!isLoading()">Loading spinner...</div>
<div *ngIf="error()">Error: {{ error() }}</div>
<div *ngIf="data()">{{ data() }}</div>

C. <div *ngIf="error()">Loading spinner...</div>
<div *ngIf="isLoading()">Error: {{ error() }}</div>
<div *ngIf="data()">{{ data() }}</div>

D. <div *ngIf="data()">Loading spinner...</div>
<div *ngIf="isLoading()">Error: {{ error() }}</div>
<div *ngIf="error()">{{ data() }}</div>

Solution

1. Step 1: Understand state priorities

   Loading state should show spinner first, then error if exists, then data if no loading or error.

2. Step 2: Analyze each template option

   <div *ngIf="isLoading()">Loading spinner...</div>
   <div *ngIf="error()" role="alert">Error: {{ error() }}</div>
   <div *ngIf="!isLoading() && !error()">{{ data() }}</div>

   correctly shows loading when isLoading() is true, error message if error() is truthy, and data only if not loading and no error. The other options mix conditions incorrectly or show wrong messages for states.

3. Final Answer:

   <pre><div *ngIf="isLoading()">Loading spinner...</div> <div *ngIf="error()" role="alert">Error: {{ error() }}</div> <div *ngIf="!isLoading() && !error()">{{ data() }}</div></pre> -> Option A

4. Quick Check:

   Loading > Error > Data display order [OK]

Hint: Show loading first, then error, then data with *ngIf [OK]

Common Mistakes:

• Showing data while still loading
• Displaying error message incorrectly
• Mixing up *ngIf conditions order