Migrating from observables to signals in Angular

Introduction

Signals provide a simpler way to manage reactive data in Angular. Migrating from observables to signals helps write cleaner and more efficient code.

You want to simplify your component's reactive data handling.

You are updating an Angular app to use the latest reactive features.

You want to reduce boilerplate code for subscriptions and unsubscriptions.

You want better performance with automatic change detection.

You want to improve code readability and maintainability.

Syntax

Angular

const signalName = signal(initialValue);

// To update the signal
signalName.set(newValue);

// To read the signal value
const value = signalName();

Signals are functions that hold a value and notify when it changes.

Use signal() to create a signal with an initial value.

Examples

This creates a signal count starting at 0, updates it to 5, then logs 5.

Angular

import { signal } from '@angular/core';

const count = signal(0);

count.set(5);
console.log(count());

Signal userName holds a string and can be read by calling it as a function.

Angular

import { signal } from '@angular/core';

const userName = signal('Alice');

// Reading the signal
console.log(userName());

Boolean signals can track states like login status.

Angular

import { signal } from '@angular/core';

const isLoggedIn = signal(false);

// Update signal when user logs in
isLoggedIn.set(true);

Sample Program

This Angular component uses a signal count to track a number. Clicking the button increases the count. The template updates automatically when the signal changes.

Angular

import { Component, signal } from '@angular/core';

@Component({
  selector: 'app-counter',
  standalone: true,
  template: `
    <h2>Counter: {{ count() }}</h2>
    <button (click)="increment()">Increment</button>
  `
})
export class CounterComponent {
  count = signal(0);

  increment() {
    this.count.set(this.count() + 1);
  }
}

Important Notes

Signals automatically trigger Angular's change detection when updated.

Unlike observables, signals do not require manual subscription or unsubscription.

Use signals for simpler reactive state management in Angular components.

Summary

Signals replace observables for simpler reactive data handling.

Use signal() to create reactive values that update the UI automatically.

Migrating reduces code complexity and improves performance.

Practice

1. What is the main benefit of migrating from Observable to signal() in Angular?

easy

A. More complex code but better performance

B. Signals require manual subscription management

C. Simpler reactive data handling with automatic UI updates

D. Signals do not support reactive updates

Solution

1. Step 1: Understand the purpose of signals

   Signals in Angular provide a simpler way to handle reactive data by automatically updating the UI when the data changes.

2. Step 2: Compare with observables

   Observables require subscriptions and manual management, while signals reduce this complexity and improve performance.

3. Final Answer:

   Simpler reactive data handling with automatic UI updates -> Option C

4. Quick Check:

   Signals simplify reactivity = B [OK]

Hint: Signals auto-update UI, observables need subscriptions [OK]

Common Mistakes:

• Thinking signals require manual subscriptions
• Believing signals increase code complexity
• Assuming signals do not update UI reactively

2. Which of the following is the correct way to create a signal in Angular?

easy

A. const count = createSignal(0);

B. const count = new Signal(0);

C. const count = observable(0);

D. const count = signal(0);

Solution

1. Step 1: Recall Angular signal creation syntax

   Angular uses the signal() function to create reactive signals.

2. Step 2: Check options for correct syntax

   Only const count = signal(0); matches Angular's official syntax.

3. Final Answer:

   const count = signal(0); -> Option D

4. Quick Check:

   Use signal() function = C [OK]

Hint: Use signal() function, not new or createSignal [OK]

Common Mistakes:

• Using new Signal() instead of signal()
• Confusing with createSignal() from other frameworks
• Using observable() which is for RxJS

3. Given this Angular code migrating from observable to signal:

const count = signal(0);

function increment() {
  count.set(count() + 1);
}

increment();
increment();
console.log(count());

What will be logged to the console?

medium

A. 0

B. 2

C. undefined

D. 1

Solution

1. Step 1: Understand signal initial value and increments

   The signal count starts at 0. Each call to increment() adds 1.

2. Step 2: Calculate final value after two increments

   After two calls, count is 0 + 1 + 1 = 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   0 + 2 increments = 2 [OK]

Hint: Signals hold value, use .set() and () to get value [OK]

Common Mistakes:

• Forgetting to call count() to get value
• Assuming count is immutable without .set()
• Confusing initial value with updated value

4. What is wrong with this migration from observable to signal?

const count = signal(0);

count.subscribe(value => console.log(value));

count.set(5);

medium

A. Signals do not have a subscribe method

B. You must call count() instead of count.set()

C. Signals require new keyword to create

D. count.set() does not update the signal value

Solution

1. Step 1: Check signal API differences from observables

   Signals do not have a subscribe method; that is an observable feature.

2. Step 2: Identify correct way to react to signal changes

   To react to signals, use computed signals or effects, not subscribe.

3. Final Answer:

   Signals do not have a subscribe method -> Option A

4. Quick Check:

   Signals lack subscribe() = A [OK]

Hint: Signals use effects, not subscribe() [OK]

Common Mistakes:

• Trying to subscribe to signals like observables
• Confusing signal() with observable()
• Using count() incorrectly as a setter

5. You have this observable-based Angular code:

count$ = new BehaviorSubject(0);

increment() {
  this.count$.next(this.count$.value + 1);
}

How would you migrate this to use signals correctly?

hard

A. const count = signal(0);

function increment() {
count.set(count() + 1);
}

B. const count = signal(0);

function increment() {
count = count() + 1;
}

C. const count = new signal(0);

function increment() {
count.set(count() + 1);
}

D. const count = signal(0);

function increment() {
count.next(count() + 1);
}

Solution

1. Step 1: Replace BehaviorSubject with signal()

   Use signal(0) to create a reactive value starting at 0.

2. Step 2: Update increment function to use .set()

   Use count.set(count() + 1) to update the signal's value correctly.

3. Final Answer:

   const count = signal(0); function increment() { count.set(count() + 1); } -> Option A

4. Quick Check:

   Use signal() and .set() to update = A [OK]

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

Common Mistakes:

• Trying to assign directly to signal variable
• Using new keyword with signal()
• Calling next() on a signal