Using Observables

Search…
Using Observables
Let's take a look at a basic example of how to create and use an Observable in an Angular component:
1
import {Component} from '@angular/core';
2
import {Observable} from 'rxjs/Observable';
3
​
4
@Component({
5
    selector: 'app',
6
    template: `
7
      <b>Angular Component Using Observables!</b>
8
​
9
      <h6 style="margin-bottom: 0">VALUES:</h6>
10
      <div *ngFor="let value of values">- {{ value }}</div>
11
​
12
      <h6 style="margin-bottom: 0">ERRORs:</h6>
13
      <div>Errors: {{anyErrors}}</div>
14
​
15
      <h6 style="margin-bottom: 0">FINISHED:</h6>
16
      <div>Finished: {{ finished }}</div>
17
​
18
      <button style="margin-top: 2rem;" (click)="init()">Init</button>
19
    `
20
})
21
export class MyApp {
22
​
23
  private data: Observable<Array<number>>;
24
  private values: Array<number> = [];
25
  private anyErrors: boolean;
26
  private finished: boolean;
27
​
28
  constructor() {
29
  }
30
​
31
  init() {
32
      this.data = new Observable(observer => {
33
          setTimeout(() => {
34
              observer.next(42);
35
          }, 1000);
36
​
37
          setTimeout(() => {
38
              observer.next(43);
39
          }, 2000);
40
​
41
          setTimeout(() => {
42
              observer.complete();
43
          }, 3000);
44
      });
45
​
46
      let subscription = this.data.subscribe(
47
          value => this.values.push(value),
48
          error => this.anyErrors = true,
49
          () => this.finished = true
50
      );
51
  }
52
​
53
}
Copied!
​View Example​
First we import Observable into our component from rxjs/Observable. Next, in our constructor we create a new Observable. Note that this creates an Observable data type that contains data of number type. This illustrates the stream of data that Observables offer as well as giving us the ability to maintain integrity of the type of data we are expecting to receive.
Next we call subscribe on this Observable which allows us to listen in on any data that is coming through. In subscribing we use three distinctive callbacks: the first one is invoked when receiving new values, the second for any errors that arise and the last represents the function to be invoked when the sequence of incoming data is complete and successful.
We can also use forEach to listen for incoming data. The key difference between forEach and subscribe is in how the error and completion callbacks are handled. The forEach call only accepts the 'next value' callback as an argument; it then returns a promise instead of a subscription.
When the Observable completes, the promise resolves. When the Observable encounters an error, the promise is rejected.
You can think of Observable.of(1, 2, 3).forEach(doSomething) as being semantically equivalent to:
1
new Promise((resolve, reject) => {
2
  Observable.of(1, 2, 3).subscribe(
3
    doSomething,
4
    reject,
5
    resolve);
6
});
Copied!
The forEach pattern is useful for a sequence of events you only expect to happen once.
1
export class MyApp {
2
​
3
  private data: Observable<Array<number>>;
4
  private values: Array<number> = [];
5
  private anyErrors: boolean;
6
  private finished: boolean;
7
​
8
  constructor() {
9
  }
10
​
11
  init() {
12
      this.data = new Observable(observer => {
13
          setTimeout(() => {
14
              observer.next(42);
15
          }, 1000);
16
​
17
          setTimeout(() => {
18
              observer.next(43);
19
          }, 2000);
20
​
21
          setTimeout(() => {
22
              observer.complete();
23
          }, 3000);
24
​
25
          this.status = "Started";
26
      });
27
​
28
      let subscription = this.data.forEach(v => this.values.push(v))
29
            .then(() => this.status = "Ended");
30
  }
31
​
32
}
Copied!
​View Example​
Observables
Error Handling
Last modified 2yr ago
Copy link