Creating observables in Angular

Introduction

Observables let you watch for changes or events over time. They help your app react smoothly when data updates.

When you want to get data from a server and update the screen automatically.

When you need to listen to user actions like clicks or typing.

When you want to handle streams of data like messages or sensor readings.

When you want to combine or transform multiple data sources easily.

Syntax

Angular

import { Observable } from 'rxjs';

const myObservable = new Observable(subscriber => {
  const value = 'some value';
  // send data to subscriber
  subscriber.next(value);
  // complete when done
  subscriber.complete();
});

The Observable constructor takes a function that controls how data is sent.

Use subscriber.next() to send data, and subscriber.complete() to say no more data will come.

Examples

This observable sends one message 'Hello' and then finishes.

Angular

import { Observable } from 'rxjs';

const simpleObservable = new Observable(subscriber => {
  subscriber.next('Hello');
  subscriber.complete();
});

This observable sends numbers 0 to 3 every second, then stops.

Angular

import { Observable } from 'rxjs';

const countObservable = new Observable(subscriber => {
  let count = 0;
  const interval = setInterval(() => {
    subscriber.next(count++);
    if (count > 3) {
      subscriber.complete();
      clearInterval(interval);
    }
  }, 1000);
});

Sample Program

This Angular component creates an observable that sends a greeting after 2 seconds and then completes after 3 seconds. The message updates on the screen accordingly.

Angular

import { Component } from '@angular/core';
import { Observable } from 'rxjs';

@Component({
  selector: 'app-observable-demo',
  template: `
    <h2>Observable Demo</h2>
    <p>Message: {{ message }}</p>
  `
})
export class ObservableDemoComponent {
  message = 'Waiting...';

  constructor() {
    const greeting$ = new Observable<string>(subscriber => {
      setTimeout(() => subscriber.next('Hello from Observable!'), 2000);
      setTimeout(() => subscriber.complete(), 3000);
    });

    greeting$.subscribe({
      next: msg => this.message = msg,
      complete: () => this.message += ' (completed)'
    });
  }
}

Important Notes

Always unsubscribe from observables in real apps to avoid memory leaks, especially for long-lived streams.

Observables can send multiple values over time, unlike promises that send only one.

Summary

Observables let you watch and react to data or events over time.

Create them using new Observable() and send data with subscriber.next().

Use observables to build responsive and interactive Angular apps.

Practice

1. What is the main purpose of creating an observable in Angular?

easy

A. To create a new component

B. To watch and react to data or events over time

C. To style HTML elements

D. To define routes in the app

Solution

1. Step 1: Understand observable concept

   Observables let you watch data or events and respond when they change.

2. Step 2: Identify purpose in Angular

   Angular uses observables to handle asynchronous data streams and events.

3. Final Answer:

   To watch and react to data or events over time -> Option B

4. Quick Check:

   Observable purpose = watch/react data [OK]

Hint: Observables track data changes over time [OK]

Common Mistakes:

• Confusing observables with components
• Thinking observables style elements
• Mixing observables with routing

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

easy

A. const obs = new Observable(subscriber => { subscriber.next('Hello'); });

B. const obs = Observable.create('Hello');

C. const obs = new Observable.next('Hello');

D. const obs = Observable('Hello');

Solution

1. Step 1: Recall Observable creation syntax

   Use new Observable() with a function receiving a subscriber.

2. Step 2: Check each option

   Only const obs = new Observable(subscriber => { subscriber.next('Hello'); }); correctly uses new Observable(subscriber => subscriber.next(...)).

3. Final Answer:

   const obs = new Observable(subscriber => { subscriber.next('Hello'); }); -> Option A

4. Quick Check:

   Correct syntax uses new Observable with subscriber function [OK]

Hint: Use new Observable(subscriber => ...) to create [OK]

Common Mistakes:

• Using Observable.create which is deprecated
• Calling next on Observable directly
• Trying to call Observable as a function

3. What will be the output when subscribing to this observable?

const obs = new Observable(subscriber => { subscriber.next(1); subscriber.next(2); subscriber.complete(); subscriber.next(3); });
obs.subscribe(value => console.log(value));

medium

A. 1 2

B. 3

C. 1 2 3

D. No output

Solution

1. Step 1: Analyze subscriber.next calls

   The observable sends 1, then 2, then calls complete(), then tries to send 3.

2. Step 2: Understand complete behavior

   After complete() is called, no more values are sent, so 3 is ignored.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   complete stops emissions, so output = 1 2 [OK]

Hint: complete() stops further values from emitting [OK]

Common Mistakes:

• Expecting values after complete()
• Ignoring complete() effect
• Thinking all next() calls always emit

4. Identify the error in this observable creation code:

const obs = new Observable(subscriber => { subscriber.next('Hi'); subscriber.error('Oops'); subscriber.next('Bye'); });

medium

A. No error, code is correct

B. Missing subscriber.complete call

C. Observable constructor syntax is wrong

D. Calling subscriber.next after subscriber.error

Solution

1. Step 1: Review observable error handling

   After calling subscriber.error(), the observable stops and no further next() calls run.

2. Step 2: Check code sequence

   Here, subscriber.next('Bye') is called after error, which is invalid and ignored.

3. Final Answer:

   Calling subscriber.next after subscriber.error -> Option D

4. Quick Check:

   next after error is invalid [OK]

Hint: No next() calls after error() [OK]

Common Mistakes:

• Thinking complete() is required after error()
• Believing next() after error() runs
• Confusing error() with complete()

5. You want to create an observable that emits numbers 1 to 3 with a delay of 1 second between each. Which code correctly achieves this behavior?

hard

A. const obs = new Observable(subscriber => { [1,2,3].forEach(n => { setTimeout(() => subscriber.next(n), 1000); }); });

B. const obs = new Observable(subscriber => { for(let n=1; n<=3; n++) { setTimeout(() => subscriber.next(n), 1000); } });

C. const obs = new Observable(subscriber => { let n=1; const interval = setInterval(() => { subscriber.next(n); if(n===3) clearInterval(interval); n++; }, 1000); });

D. const obs = new Observable(subscriber => { subscriber.next(1); subscriber.next(2); subscriber.next(3); });

Solution

1. Step 1: Understand timing requirements

   We need to emit 1, 2, 3 spaced by 1 second each.

2. Step 2: Analyze each option's timing

   const obs = new Observable(subscriber => { [1,2,3].forEach(n => { setTimeout(() => subscriber.next(n), 1000); }); }); emits 1,2,3 all after 1 second simultaneously.
   const obs = new Observable(subscriber => { for(let n=1; n<=3; n++) { setTimeout(() => subscriber.next(n), 1000); } }); emits all after 1 second simultaneously.
   const obs = new Observable(subscriber => { let n=1; const interval = setInterval(() => { subscriber.next(n); if(n===3) clearInterval(interval); n++; }, 1000); }); uses setInterval to emit each number every 1 second and stops after 3.
   const obs = new Observable(subscriber => { subscriber.next(1); subscriber.next(2); subscriber.next(3); }); emits all immediately without delay.

3. Final Answer:

   const obs = new Observable(subscriber => { let n=1; const interval = setInterval(() => { subscriber.next(n); if(n===3) clearInterval(interval); n++; }, 1000); }); -> Option C

4. Quick Check:

   setInterval with clearInterval emits spaced values [OK]

Hint: Use setInterval and clearInterval for timed emissions [OK]

Common Mistakes:

• Using forEach with setTimeout causes all to run at once
• Not clearing interval causing infinite emissions
• Emitting all values immediately without delay