Creating observables in Angular - Practice Exercises

Challenge - 5 Problems

❓ component_behavior

intermediate

Observable subscription behavior in Angular

Consider this Angular component code that creates an observable and subscribes to it. What will be logged to the console when the component initializes?

Angular

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

@Component({
  selector: 'app-test',
  template: `<p>Check console output</p>`
})
export class TestComponent implements OnInit {
  data$: Observable<number> = new Observable(observer => {
    observer.next(1);
    observer.next(2);
    observer.complete();
  });

  ngOnInit() {
    this.data$.subscribe(value => console.log(value));
  }
}

A 1

B 2

C 1 2

D No output, observable never emits

💡 Hint

Think about how many times observer.next is called before complete.

The observable emits two values, 1 and 2, before completing. The subscription logs each emitted value in order.

📝 Syntax

intermediate

Correct syntax to create an observable emitting a single value

Which option correctly creates an observable that emits the string 'hello' once and then completes?

A Observable.of('hello')

B new Observable(observer => { observer.next('hello'); observer.complete(); })

C Observable.create(observer => { observer.next('hello'); })

D new Observable(observer => { observer.emit('hello'); observer.complete(); })

💡 Hint

Check the method names and how observables are created in RxJS.

Option B uses the correct Observable constructor and calls observer.next and observer.complete properly.

Option B is invalid because 'of' is a standalone function, not a method on Observable.

Option B uses deprecated Observable.create and misses observer.complete.

Option B uses observer.emit which does not exist.

🔧 Debug

advanced

Why does this observable never emit values?

Given this observable code, why does the subscription never log any values?

Angular

const obs$ = new Observable(observer => {
  setTimeout(() => {
    observer.next('data');
    observer.complete();
  }, 1000);
});

obs$.subscribe(value => console.log(value));

A The observable is cold and subscription triggers the emission after 1 second, so it logs 'data' after 1 second.

B The observable never emits because setTimeout is asynchronous and observer.next is not called synchronously.

C The subscription is missing, so no values are emitted.

D The observable completes before emitting any value.

💡 Hint

Think about how asynchronous code inside observables works.

The observable is cold, so the code inside runs when subscribed. The setTimeout delays emission by 1 second, then emits 'data' and completes. The subscription logs 'data' after 1 second.

❓ state_output

advanced

State of subscription after multiple emissions

What is the state of the subscription after this observable emits three values and completes?

Angular

const obs$ = new Observable(observer => {
  observer.next(10);
  observer.next(20);
  observer.next(30);
  observer.complete();
});

let received = [];
obs$.subscribe(value => received.push(value));

A received is empty and subscription is closed

B received contains [10, 20] and subscription is still open

C received contains [30] and subscription is closed

D received contains [10, 20, 30] and subscription is closed

💡 Hint

Consider what happens when observer.complete is called.

The observable emits three values in order, so received has all three. After complete, the subscription is closed and no more values can be emitted.

🧠 Conceptual

expert

Difference between cold and hot observables in Angular

Which statement correctly describes the difference between cold and hot observables in Angular?

A Cold observables start emitting values only when subscribed; hot observables emit values regardless of subscriptions.

B Cold observables emit values regardless of subscriptions; hot observables start emitting only when subscribed.

C Cold observables cannot be multicasted; hot observables cannot be unsubscribed.

D Cold observables are synchronous; hot observables are always asynchronous.

💡 Hint

Think about when the data starts flowing in each observable type.

Cold observables wait until someone subscribes before emitting data. Hot observables emit data independently of subscriptions, so subscribers may miss some values.