Skip to content

5. Observables und geteilter Zustand

5.1. Beispiel 19: RxJS-Observables

Wir sind bereits zwei Arten von Werten begegnet, die sich im Lauf der Zeit ändern: Signalen, die immer einen aktuellen Wert haben, und Promises, die zu einem späteren Zeitpunkt einen einzigen Wert liefern. [Angular] verwendet eine dritte Art: Observables, bereitgestellt von der Bibliothek [RxJS]. Ein Observable ist ein Strom von Werten, die im Lauf der Zeit eintreffen: Tastenanschläge, Timer-Ticks, Router-Ereignisse (Beispiel 17), die Antwort eines Servers (Beispiel 22).

Ihre Stärke liegt in ihren Operatoren: Funktionen, die einen Strom in einen anderen umwandeln (filtern, warten, eine veraltete Anfrage verwerfen usw.). Dieses Beispiel stellt die wichtigsten davon in drei Szenarien vor.

// =========================================================================
// 19-rxjs/src/app/app.ts - die Observables der Bibliothek RxJS
// -------------------------------------------------------------------------
// Ein OBSERVABLE ist ein STREAM von Werten, die im Lauf der Zeit eintreffen (die
// Tastendrücke, die Ticks eines Timers, die Antwort eines Servers...).
// Angular nutzt sie intensiv: Der HTTP-Client (Beispiel 22) und der Router
// (Beispiel 17) liefern Observables.
//   - observable.subscribe(function): wir ABONNIEREN; die Funktion erhält
//     jeden Wert. Es passiert nichts, solange niemand abonniert hat;
//   - observable.pipe(op1, op2...): ein NEUER Stream, umgewandelt durch
//     OPERATOREN (map, filter, debounceTime, switchMap...);
//   - toSignal(observable): ein Signal, dessen Wert der zuletzt empfangene Wert ist
//     (automatisches Abonnieren und Abbestellen).
// =========================================================================

import { Component, DestroyRef, inject, signal } from '@angular/core';
import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
import { debounceTime, delay, distinctUntilChanged, filter, interval, map, Observable, of, Subject, switchMap, take, tap } from 'rxjs';

const DOCTORS = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];

@Component({
  selector: 'app-root',
  templateUrl: './app.html',
})
export class App {
  protected readonly log = signal<string[]>([]);

  // 2. ein Timer: 0, 1, 2... jede Sekunde; take(20): 20 Werte,
  // dann ist der Stream beendet; map: jeder Wert wird umgewandelt
  private readonly seconds$ = interval(1000).pipe(
    take(20),
    map((n) => 20 - n - 1),
  );
  // toSignal: der Countdown als Signal
  protected readonly countdown = toSignal(this.seconds$, { initialValue: 20 });

  // 3. eine Suche "während der Eingabe": ein Subject ist ein Observable,
  // in das wir selbst Werte EINSPEISEN (next)
  private readonly inputs = new Subject<string>();
  protected readonly results = toSignal(
    this.inputs.pipe(
      map((text) => text.trim().toLowerCase()),
      debounceTime(400), // wir warten 400 ms ohne Tastendruck
      distinctUntilChanged(), // wir ignorieren einen Text, der mit dem vorherigen identisch ist
      filter((text) => text.length >= 2),
      tap((text) => this.trace(`search sent: "${text}"`)),
      // switchMap: eine Suche pro Text; trifft ein neuer Text ein,
      // bevor die Antwort da ist, wird die alte Suche ABGEBROCHEN
      switchMap((text) => this.search(text)),
    ),
    { initialValue: [] as string[] },
  );

  constructor() {
    // 1. ein von Hand gebautes Observable: es sendet drei Werte und endet dann
    const threeValues = new Observable<string>((subscriber) => {
      subscriber.next('one');
      subscriber.next('two');
      setTimeout(() => {
        subscriber.next('three (one second later)');
        subscriber.complete();
      }, 1000);
    });
    // takeUntilDestroyed: das Abonnement endet, wenn die Komponente verschwindet
    threeValues.pipe(takeUntilDestroyed(inject(DestroyRef))).subscribe({
      next: (value) => this.trace(`received: ${value}`),
      complete: () => this.trace('stream completed'),
    });
  }

  protected onInput(text: string): void {
    this.inputs.next(text);
  }

  // ein simulierter "Server": die Antwort trifft nach einer zufälligen Verzögerung ein
  private search(text: string): Observable<string[]> {
    const found = DOCTORS.filter((m) => m.toLowerCase().includes(text));
    return of(found).pipe(delay(200 + Math.random() * 600));
  }

  private trace(message: string): void {
    this.log.update((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);
  }
}
  • Zeile 18: Die verwendeten Funktionen und Operatoren werden alle aus [rxjs] importiert;

Ein von Hand erstelltes Observable:

  • Zeilen 57–64: Ein Observable wird aus einer Funktion erzeugt, die für jeden Abonnenten aufgerufen wird. Es sendet Werte mit [next] (Zeilen 58, 59, 61) und signalisiert dann das Ende des Stroms mit [complete] (Zeile 62);
  • Zeile 66: [subscribe]: Der Code abonniert den Strom. Es passiert nichts, bis jemand abonniert: Die Funktion in den Zeilen 57–64 wird erst dann ausgeführt. Das Objekt, das an [subscribe] übergeben wird, legt fest, was mit jedem Wert (Zeile 67) und mit dem Ende des Stroms (Zeile 68) geschehen soll;
  • Zeile 66: [pipe] verkettet Operatoren. [takeUntilDestroyed] beendet das Abonnement, wenn die Komponente verschwindet: Ein vergessenes Abonnement würde für eine Komponente weiterlaufen, die nicht mehr existiert.

Ein Countdown:

  • Zeile 31: [interval(1000)] sendet jede Sekunde 0, 1, 2 ... unbegrenzt;
  • Zeile 32: [take(20)] behält nur die ersten zwanzig Werte und beendet dann den Strom;
  • Zeile 33: [map] wandelt jeden Wert um: 0, 1, 2 ... werden zu 19, 18, 17 ...;
  • Zeile 36: [toSignal] wandelt den Strom in ein Signalum, das auf den zuletzt empfangenen Wert gesetzt ist und das das Template wie jedes andere Signal liest. [toSignal] abonniert den Strom und beendet das Abonnement, wenn die Komponente verschwindet. [initialValue]: der Wert des Signals vor dem ersten Wert des Stroms.

Per Konvention endet der Name einer Variablen, die ein Observable enthält, mit [$] (Zeile 31).

Eine Suche während der Eingabe:

Dies ist ein klassisches Beispiel für Observables: Wir wollen nach Ärzten suchen, deren Namen den eingegebenen Text enthalten, ohne bei jedem Tastenanschlag eine Anfrage an den Server zu senden und ohne zu riskieren, dass eine langsame Antwort eine neuere überschreibt.

  • Zeile 40: Ein ***[Subject] ist ein Observable, in das wir selbst Werte *einspeisen, und zwar mit ***[next]***: Zeile 73, bei jedem Tastenanschlag (das Template ruft [onInput] bei jedem [input]-Ereignis auf);
  • Zeile 43: Der Text wird bereinigt (Leerzeichen entfernt, in Kleinbuchstaben umgewandelt);
  • Zeile 44: [debounceTime(400)] gibt nur dann einen Wert aus, wenn 400 ms lang kein weiterer Wert eintrifft: Solange der Benutzer tippt, wird nichts gesendet;
  • Zeile 45: [distinctUntilChanged] ignoriert einen Wert, der mit dem vorherigen identisch ist („pel“, dann „pelx“, sofort wieder gelöscht: wieder „pel“);
  • Zeile 46: [filter] behält nur Zeichenketten mit mindestens zwei Buchstaben;
  • Zeile 47: [tap] führt eine Aktion aus, ohne den Strom zu verändern: hier eine Zeile im Protokoll;
  • Zeile 50: [switchMap] ersetzt jeden Text durch das Ergebnis seiner Suche (Zeilen 77–80: ein simulierter Server, der nach einer zufälligen Verzögerung antwortet). Trifft ein neuer Text vor der Antwort ein, wird die vorherige Suche verworfen: Ihre Antwort wird nie angezeigt. Mit dem echten HTTP-Client würde die Anfrage sogar abgebrochen;
  • Zeile 52: Das Signal [results] ist eine leere Liste, solange keine Suche erfolgreich war.
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 19 - RxJS observables</h1>

  <div class="card p-3 mb-3">
    <h2 class="h6">A countdown (interval, take, map, toSignal)</h2>
    <p class="display-6 mb-0">{{ countdown() }}</p>
  </div>

  <div class="card p-3 mb-3">
    <h2 class="h6">A search as you type (debounceTime, switchMap)</h2>
    <input class="form-control mb-2" placeholder="at least two letters: pel, dur..." (input)="onInput(field.value)" #field>
    <ul class="mb-0">
      @for (r of results(); track r) {
        <li>{{ r }}</li>
      } @empty {
        <li class="text-muted">no result</li>
      }
    </ul>
  </div>

  <h2 class="h6">Log</h2>
  <ol class="small">
    @for (line of log(); track $index) {
      <li>{{ line }}</li>
    }
  </ol>
</div>
  • Zeile 6: der Countdown, ein Signal;
  • Zeile 11: [#field] ist eine Template-Variable: Sie verweist auf das Element [<input>], dessen Wert bei jedem Tastenanschlag übergeben wird;
  • Zeilen 13–17: die Suchergebnisse.

[npm start 19-rxjs]; geben Sie „pe“ ein und, etwas später, „l“:

Image

Das Protokoll zeigt beide Suchen: „pe“ (nach 400 ms Pause gesendet), dann „pel“.

Signale oder Observables? Beide existieren in [Angular] nebeneinander, mit unterschiedlichen Rollen:

 
Signal
Observable
Wert
hat immer einen aktuellen Wert, der jederzeit gelesen werden kann
sendet Werte im Lauf der Zeit; kein „aktueller“ Wert
Verwendung
der Zustand der Anwendung (was angezeigt wird)
Ereignisse und asynchrone Operationen (Anfragen, Timer, Tastenanschläge)
Abonnement
automatisch (Templates, [computed], [effect])
explizit ([subscribe]) oder über [toSignal]
Hauptmerkmale
Einfachheit
Operatoren: warten, kombinieren, verwerfen

Der Trend in [Angular] geht dahin, den Zustand in Signalen zu speichern und Observables für Fälle zu reservieren, in denen ihre Operatoren nützlich sind. [toSignal] und [toObservable] wechseln zwischen beiden. In der Fallstudie werden die HTTP-Anfragen in Promises umgewandelt ([firstValueFrom], Beispiel 22), und der Zustand wird in Signalen gekapselt; nur die Router-Ereignisse werden als Observables abgehört.

5.2. Beispiel 20: Ein geteilter Zustand

Mehrere Komponenten benötigen oft dieselben Daten: den angemeldeten Benutzer (die Navigationsleiste, Guards, Seiten), anzuzeigende Nachrichten und die gewählte Sprache. Wo sollen diese Daten gespeichert werden? Der [NestJS]-Kurs behandelte dieselbe Frage auf der Serverseite (Gültigkeitsbereiche Anwendung, Anfrage und Sitzung). Dieses Beispiel überträgt sie auf den Browser, mit drei „Gültigkeitsbereichen“:

  • der lokale Zustand einer Komponente, gespeichert in ihren eigenen Variablen: Er verschwindet, wenn die Komponente zerstört wird;
  • der Zustand eines Root-Services: von allen Komponenten geteilt, überlebt er deren Entfernung, aber nicht das Neuladen der Seite (F5), das die Anwendung neu startet;
  • der im localStorage des Browsers gespeicherte Zustand: Er überlebt das Neuladen der Seite und sogar das Schließen des Browsers.
20-shared-state/src/app/
├── state/
│   ├── cart.service.ts          a shared state
│   └── preferences.service.ts   a state that survives F5
├── components/
│   ├── shop.ts                  adds to the cart
│   ├── cart-summary.ts          displays the cart
│   └── local-counter.ts         a local state
├── app.ts
└── app.html

5.2.1. Ein Service, der den Zustand enthält

// =========================================================================
// 20-shared-state/src/app/state/cart.service.ts - ein GETEILTER ZUSTAND
// -------------------------------------------------------------------------
// Ein Root-Service (providedIn: 'root'), der Signale enthält, ist ein
// "Store": EINE einzige Instanz für die ganze Anwendung, die
// alle Komponenten teilen. Übliche Gliederung:
//   - der ZUSTAND: PRIVATE Signale, nur vom Service änderbar;
//   - SCHREIBGESCHÜTZTE Signale (asReadonly) und computeds, die von
//     den Komponenten gelesen werden;
//   - Methoden (die "Aktionen"), die als einzige den Zustand ändern.
// Der Service lebt so lange wie die Anwendung: Er überlebt das Entfernen einer
// Komponente ... aber nicht das Neuladen der Seite (F5), das die
// Anwendung neu startet. (Keine zusätzliche Bibliothek nötig, wie Pinia
// für Vue.js: Services und Signale genügen.)
// =========================================================================

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

export interface Item {
  label: string;
  price: number;
}

@Injectable({ providedIn: 'root' })
export class CartService {
  private readonly _items = signal<Item[]>([]);

  readonly items = this._items.asReadonly();
  readonly count = computed(() => this._items().length);
  readonly total = computed(() => this._items().reduce((s, a) => s + a.price, 0));

  add(item: Item): void {
    this._items.update((a) => [...a, item]);
  }

  clear(): void {
    this._items.set([]);
  }
}

Ein Root-Service, der Signale enthält, fungiert als Store ([store]): eine einzige Instanz, die von der gesamten Anwendung geteilt wird. Er ist in drei Teile gegliedert:

  • Zeile 26: der Zustand in einem privaten Signal: Keine Komponente kann ihn direkt ändern;
  • Zeilen 28–30: was die Komponenten lesen: der schreibgeschützte Zustand ([asReadonly]) und berechnete Werte ([computed]);
  • Zeilen 32–38: die Aktionen, die einzigen Methoden, die den Zustand ändern können.

Dieser Ansatz hat einen entscheidenden Vorteil: Wenn ein Warenkorb ungültig ist, können die einzigen möglichen Änderungen innerhalb der Methoden des Services stattgefunden haben. Mit [Vue.js] wird dafür üblicherweise eine Bibliothek ([Pinia]) verwendet; mit [Angular] genügen Services und Signale allein.

5.2.2. Komponenten, die ihn teilen

// 20-shared-state/src/app/components/shop.ts - FÜGT zum geteilten Warenkorb HINZU
import { Component, inject } from '@angular/core';
import { Item, CartService } from '../state/cart.service';

@Component({
  selector: 'app-shop',
  template: `
    <div class="card p-3 h-100">
      <h2 class="h6">Shop</h2>
      @for (p of products; track p.label) {
        <button class="btn btn-sm btn-outline-primary mb-2" (click)="cart.add(p)">+ {{ p.label }} (€{{ p.price }})</button>
      }
    </div>
  `,
})
export class Shop {
  protected readonly cart = inject(CartService);
  protected readonly products: Item[] = [
    { label: 'Consultation', price: 30 },
    { label: 'Vaccine', price: 12.5 },
  ];
}
  • Zeile 17: Die Komponente injiziert den Service;
  • Zeile 11: Sie ruft eine Aktion auf.
// 20-shared-state/src/app/components/cart-summary.ts - LIEST denselben Warenkorb
import { Component, inject } from '@angular/core';
import { CartService } from '../state/cart.service';

@Component({
  selector: 'app-cart-summary',
  template: `
    <div class="card p-3 h-100">
      <h2 class="h6">Cart</h2>
      <p class="mb-2">{{ cart.count() }} item(s), €{{ cart.total() }}</p>
      <button class="btn btn-sm btn-outline-danger align-self-start" [disabled]="cart.count() === 0"
              (click)="cart.clear()">Clear</button>
    </div>
  `,
})
export class CartSummary {
  protected readonly cart = inject(CartService);
}
  • Zeile 10: Sie liest die berechneten Werte aus demselben Service;
  • Zeile 12: Sie ruft eine andere Aktion auf.

Die beiden Komponenten wissen nichts voneinander: Es gibt keine Eingaben oder Ausgaben zwischen ihnen. Sie kommunizieren über den Service.

// 20-shared-state/src/app/components/local-counter.ts - ein LOKALER Zustand, der mit der Komponente verschwindet
import { Component, signal } from '@angular/core';

@Component({
  selector: 'app-local-counter',
  template: `
    <div class="card p-3 h-100">
      <h2 class="h6">Local state</h2>
      <button class="btn btn-sm btn-outline-secondary align-self-start" (click)="clicks.set(clicks() + 1)">{{ clicks() }} click(s)</button>
    </div>
  `,
})
export class LocalCounter {
  protected readonly clicks = signal(0);
}
  • Zeile 14: ein lokaler Zustand: Jede Instanz der Komponente hat ihren eigenen Zähler, der verschwindet, wenn die Instanz zerstört wird.

5.2.3. Ein Zustand, der das Neuladen der Seite überlebt

// =========================================================================
// 20-shared-state/src/app/state/preferences.service.ts - ein Zustand, der F5 überlebt
// -------------------------------------------------------------------------
// Damit ein Datum das Neuladen der Seite oder das Schließen
// des Browsers überlebt, muss es IM Browser gespeichert werden: localStorage (ein
// kleines Wörterbuch Schlüssel -> String, spezifisch für jede Website).
//   - beim Start liest der Service localStorage erneut aus;
//   - ein Effect schreibt localStorage bei jeder Änderung neu.
// Sensible Daten (Passwort, Token) speichern wir dort NIEMALS: Jedes Skript
// der Seite kann localStorage lesen.
// =========================================================================

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

const KEY = 'example20.preferences';

export interface Preferences {
  dark: boolean;
  size: number; // Textgröße in px
}

function read(): Preferences {
  try {
    return { dark: false, size: 16, ...JSON.parse(localStorage.getItem(KEY) ?? '{}') };
  } catch {
    return { dark: false, size: 16 }; // nicht lesbarer Inhalt: Standardwerte
  }
}

@Injectable({ providedIn: 'root' })
export class PreferencesService {
  readonly preferences = signal<Preferences>(read());

  constructor() {
    effect(() => localStorage.setItem(KEY, JSON.stringify(this.preferences())));
  }

  // eine Einstellung ändert sich: wir ersetzen das Objekt (das Signal bemerkt es)
  update(change: Partial<Preferences>): void {
    this.preferences.update((p) => ({ ...p, ...change }));
  }
}
  • Zeile 15: der Schlüssel, unter dem die Einstellungen in [localStorage] gespeichert werden, einem kleinen Wörterbuch von Schlüsseln zu Zeichenketten, das für jede Website spezifisch ist;
  • Zeilen 22–28: Beim Start werden die gespeicherten Einstellungen gelesen. Die Standardwerte werden um die gespeicherten ergänzt (mithilfe des Operators [...]); nicht lesbarer Inhalt wird ignoriert (Zeile 26);
  • Zeile 32: die Einstellungen in einem Signal;
  • Zeile 35: Ein Effect (Beispiel 13) schreibt [localStorage] jedes Mal neu, wenn sich das Signal ändert: Man muss in keiner Aktion daran denken;
  • Zeilen 39–41: die Aktion, die eine oder mehrere Einstellungen ändert ([Partial<Preferences>]: ein Objekt, in dem jede Eigenschaft optional ist). Wir ersetzen das Objekt, anstatt es zu ändern: Ein Signal erkennt nur Änderungen des Werts.

Sensible Daten (Passwörter, Anmelde-Token) werden niemals im [localStorage] gespeichert: Jedes von der Seite ausgeführte Skript kann sie lesen. Deshalb wird das Anmelde-Token der Anwendung [RdvMedecins] in einem Cookie gespeichert, auf das der [JavaScript]-Code keinen Zugriff hat.

5.2.4. Die Seite

// =========================================================================
// 20-shared-state/src/app/app.ts - drei "Gültigkeitsbereiche" von Daten auf der Client-Seite
// -------------------------------------------------------------------------
// Dieselbe Frage wie Beispiel 23 des NestJS-Kurses (Anwendungs-,
// Anfrage-, Client-Scope), auf den Browser übertragen:
//   - der LOKALE Zustand einer Komponente (LocalCounter) verschwindet mit ihr;
//   - der Zustand eines Root-SERVICES (der Warenkorb) wird von allen
//     Komponenten geteilt und überlebt deren Entfernen - aber nicht F5;
//   - der in localStorage gespeicherte Zustand (die Einstellungen) überlebt F5 und das
//     Schließen des Browsers.
// Haken Sie "show the area" ab und wieder an, laden Sie dann die Seite neu: vergleichen Sie.
// =========================================================================

import { Component, inject, signal } from '@angular/core';
import { PreferencesService } from './state/preferences.service';
import { Shop } from './components/shop';
import { CartSummary } from './components/cart-summary';
import { LocalCounter } from './components/local-counter';

@Component({
  selector: 'app-root',
  imports: [Shop, CartSummary, LocalCounter],
  templateUrl: './app.html',
})
export class App {
  protected readonly prefs = inject(PreferencesService);
  protected readonly areaVisible = signal(true);
}
  • Zeile 27: ein lokaler Zustand der Root-Komponente: Wird der Bereich angezeigt?
@let p = prefs.preferences();
<div class="min-vh-100" [class.bg-dark]="p.dark" [class.text-light]="p.dark" [style.font-size.px]="p.size">
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 20 - shared state</h1>
    <div class="d-flex flex-wrap gap-4 mb-3">
      <label class="form-check-label">
        <input #dark type="checkbox" class="form-check-input" [checked]="p.dark"
               (change)="prefs.update({ dark: dark.checked })"> dark theme
      </label>
      <label>
        text size
        <input #size type="range" min="12" max="22" [value]="p.size"
               (input)="prefs.update({ size: +size.value })"> {{ p.size }} px
      </label>
      <label class="form-check-label">
        <input #area type="checkbox" class="form-check-input" [checked]="areaVisible()"
               (change)="areaVisible.set(area.checked)"> show the area
      </label>
    </div>
    @if (areaVisible()) {
      <div class="row g-3 text-body">
        <div class="col-md-4"><app-shop /></div>
        <div class="col-md-4"><app-cart-summary /></div>
        <div class="col-md-4"><app-local-counter /></div>
      </div>
    }
    <p class="mt-3 mb-2">Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
    <div class="text-body"><app-cart-summary /></div>
  </div>
</div>
  • Zeile 1: [@let] deklariert eine Template-Variable: [p] erspart die Wiederholung von [prefs.preferences()];
  • Zeile 2: Die Einstellungen gelten für die gesamte Seite: [[class.bg-dark]] setzt die Klasse, wenn der Wert wahr ist; [[style.font-size.px]] legt eine Größe in Pixeln fest;
  • Zeilen 7–8 und 12–13: Jede Änderung löst die Aktion [update] aus;
  • Zeilen 20–26: Der Bereich, der die drei Komponenten enthält, ob angezeigt oder nicht;
  • Zeile 28: eine zweite Zusammenfassung desselben Warenkorbs, außerhalb des Bereichs.

[npm start 20-shared-state]; zwei Artikel werden in den Warenkorb gelegt, und der lokale Zähler wird zweimal angeklickt:

Image

Sie können nun die drei Gültigkeitsbereiche überprüfen:

  • Deaktivieren und aktivieren Sie „show the area“ erneut: Der lokale Zähler wurde auf 0 zurückgesetzt (die Komponente wurde neu erzeugt), der Warenkorb ist unversehrt (der Service hat überlebt);
  • Wählen Sie das dunkle Design und laden Sie die Seite neu (F5): Der Warenkorb ist leer (die Anwendung wurde neu gestartet), das dunkle Design bleibt erhalten ([localStorage] hat überlebt).