Skip to content

5. 可观察对象与共享状态

5.1. 示例 19:RxJS 可观察对象

我们已经遇到过两种随时间变化的值:信号,它始终有一个当前值;以及Promise,它在稍后的某个时刻交付单个值。[Angular] 使用第三种类型:可观察对象,由[RxJS]库提供。可观察对象是随时间到达的值的流:按键、定时器滴答、路由器事件(示例 17)、服务器的响应(示例 22)。

它们的强大之处在于其操作符:将一个流转换为另一个流的函数(过滤、等待、丢弃已过期的请求等)。本示例通过三个场景介绍其中主要的操作符。

// =========================================================================
// 19-rxjs/src/app/app.ts - RxJS 库的 Observable
// -------------------------------------------------------------------------
// 可观察对象(OBSERVABLE)是随时间到来的值的流(STREAM)
// (按键、定时器的滴答、服务器的响应……)。
// Angular 大量使用它们:HTTP 客户端(示例 22)和路由器
// (示例 17)都返回 Observable。
//   - observable.subscribe(function):我们订阅(SUBSCRIBE);函数接收
//     每个值。只要无人订阅,就什么都不会发生;
//   - observable.pipe(op1, op2...):一个新的流,由
//     操作符(map、filter、debounceTime、switchMap...)转换而来;
//   - toSignal(observable):其值为最近收到的值的信号
//     (自动订阅和取消订阅)。
// =========================================================================

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. 定时器:每秒发出 0、1、2……;take(20):20 个值
  // 之后流完成;map:每个值都被转换
  private readonly seconds$ = interval(1000).pipe(
    take(20),
    map((n) => 20 - n - 1),
  );
  // toSignal:倒计时,以信号形式
  protected readonly countdown = toSignal(this.seconds$, { initialValue: 20 });

  // 3. “边输入边搜索”:Subject 是一个我们可以自己
  // 向其推送(next)值的 Observable
  private readonly inputs = new Subject<string>();
  protected readonly results = toSignal(
    this.inputs.pipe(
      map((text) => text.trim().toLowerCase()),
      debounceTime(400), // 等待 400 毫秒内没有按键
      distinctUntilChanged(), // 忽略与上一次相同的文本
      filter((text) => text.length >= 2),
      tap((text) => this.trace(`search sent: "${text}"`)),
      // switchMap:每个文本对应一次搜索;若新文本在响应到来
      // 之前到达,旧的搜索会被放弃
      switchMap((text) => this.search(text)),
    ),
    { initialValue: [] as string[] },
  );

  constructor() {
    // 1. 手工构建的 Observable:发出三个值,然后完成
    const threeValues = new Observable<string>((subscriber) => {
      subscriber.next('one');
      subscriber.next('two');
      setTimeout(() => {
        subscriber.next('three (one second later)');
        subscriber.complete();
      }, 1000);
    });
    // takeUntilDestroyed:组件消失时订阅停止
    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);
  }

  // 模拟的“服务器”:响应在随机延迟后到达
  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}`]);
  }
}
  • 第 18 行:所用的函数和操作符都从[rxjs]导入;

手工构建的可观察对象:

  • 第 57–64 行:可观察对象由一个函数构造,该函数会为每个订阅者调用。它使用[next] (第 58、59、61 行)发出值,然后使用[complete] (第 62 行)标示流的结束;
  • 第 66 行:[subscribe]:代码订阅该流。在有人订阅之前什么都不会发生:第 57–64 行的函数只有在此时才会执行。传递给[subscribe] 的对象指定了如何处理每个值(第 67 行)以及流的结束(第 68 行);
  • 第 66 行:[pipe] 将操作符串联起来。[takeUntilDestroyed] 会在组件消失时停止订阅:被遗忘的订阅会继续为一个已不存在的组件运行。

倒计时:

  • 第 31 行:[interval(1000)] 每秒发出 0、1、2……,无限持续;
  • 第 32 行:[take(20)] 只保留前二十个值,然后终止该流;
  • 第 33 行:[map] 转换每个值:0、1、2…… 变为 19、18、17……;
  • 第 36 行:[toSignal] 将该流转换为信号,其值被设置为最后接收到的值,模板可以像读取任何其他信号一样读取它。[toSignal] 订阅该流,并在组件消失时取消订阅。[initialValue]:流中第一个值到达之前信号的值。

按照惯例,包含可观察对象的变量名以[$] 结尾(第 31 行)。

边输入边搜索:

这是可观察对象的一个经典示例:我们希望搜索姓名包含正在输入文本的医生,同时不在每次按键时都向服务器发送请求,也不会冒着较慢的响应覆盖较新响应的风险。

  • 第 40 行:一个 ***[Subject] 是一个我们可以自行*推送值的可观察对象,使用 ***[next]***:第 73 行,在每次按键时(模板会为每个[onInput] [input]事件调用它);
  • 第 43 行:对文本进行清理(去除首尾空白,转为小写);
  • 第 44 行:[debounceTime(400)] 只有在 400 毫秒内没有其他值到达时才输出一个值:只要用户还在输入,就不会发送任何内容;
  • 第 45 行:[distinctUntilChanged] 忽略与前一个值相同的值(“pel”,然后“pelx”被立即删除:又是“pel”);
  • 第 46 行:[filter] 只保留至少包含两个字母的文本字符串;
  • 第 47 行:[tap] 执行一个操作而不修改流:此处是在日志中写入一行;
  • 第 50 行:[switchMap] 将每个文本替换为其搜索的结果 (第 77–80 行:一个在随机延迟后响应的模拟服务器)。如果在响应到达之前出现了新文本,则前一次搜索会被放弃:它的响应永远不会被显示。如果使用真实的 HTTP 客户端,该请求甚至会被取消;
  • 第 52 行:只要还没有任何搜索成功,[results]信号就是一个空列表。
<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>
  • 第 6 行:倒计时,一个信号;
  • 第 11 行:[#field] 是一个模板变量:它引用元素[<input>],每次按键时都会传递其值;
  • 第 13–17 行:搜索结果。

[npm start 19-rxjs];输入“pe”,稍后再输入“l”:

Image

日志显示了两次搜索:“pe”(在 400 毫秒的静默后发送),然后是“pel”。

信号还是可观察对象?两者在 [Angular]中并存,但角色不同:

 
信号
可观察对象
值
始终有一个当前值,可以随时读取
随时间发出值;没有“当前”值
用法
应用程序的状态 (显示的内容)
事件 和异步操作(请求、定时器、按键)
订阅
自动(模板、[computed]、[effect])
显式([subscribe]),或通过[toSignal]
关键特性
简单
操作符:等待、组合、放弃

[Angular] 的趋势是将状态存储在信号中,并将可观察对象保留给其操作符有用的场合。[toSignal] 和[toObservable] 可在两者之间转换。在案例研究中,HTTP 请求将被转换为 Promise([firstValueFrom],示例 22),状态将封装在信号中;只有路由器事件会作为可观察对象来监听。

5.2. 示例 20:共享状态

多个组件经常需要相同的数据:已登录的用户(导航栏、守卫、页面)、要显示的消息,以及所选的语言。这些数据应该存放在哪里?[NestJS]课程在服务器端讨论过同样的问题(应用程序、请求和会话作用域)。本示例将其适配到浏览器,包含三种“作用域”:

  • 组件的本地状态,存放在其自身的变量中:它会在组件被销毁时消失;
  • 根服务的状态:由所有组件共享,组件被移除后它依然存在,但页面刷新(F5)会使应用重新启动,状态随之丢失;
  • 存储在浏览器localStorage中的状态:它在页面刷新后依然存在,甚至在关闭浏览器后也不会丢失。
20-shared-state/src/app/
├── state/
│   ├── cart.service.ts          共享状态
│   └── preferences.service.ts   刷新(F5)后仍保留的状态
├── components/
│   ├── shop.ts                  添加到购物车
│   ├── cart-summary.ts          显示购物车
│   └── local-counter.ts         局部状态
├── app.ts
└── app.html

5.2.1. 包含状态的服务

// =========================================================================
// 20-shared-state/src/app/state/cart.service.ts - 共享状态
// -------------------------------------------------------------------------
// 包含信号的根服务(providedIn: 'root')就是一个
// "store":整个应用只有一个实例,
// 所有组件共享它。常见的组织方式:
//   - 状态(STATE):私有信号,只有服务能修改;
//   - 只读信号(asReadonly)和 computed,由
//     组件读取;
//   - 方法(即 "action"),是唯一修改状态的途径。
// 服务与应用同生命周期:它在组件被移除后依然存在
// ……但页面重新加载(F5)后不会保留,因为那会重启
// 应用。(无需额外的库,如 Vue.js 的
// Pinia:服务加信号就够了。)
// =========================================================================

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([]);
  }
}

包含信号的根服务充当存储(store)([store]):它只有一个实例,由整个应用共享。它分为三个部分:

  • 第 26 行:状态,保存在一个private信号中:任何组件都不能直接修改它;
  • 第 28–30 行:组件可以读取的内容:只读状态([asReadonly])和计算值([computed]);
  • 第 32–38 行:动作,即唯一可以修改状态的方法。

这种方法有一个关键好处:当购物车无效时,唯一可能的修改只发生在服务的方法内部。在[Vue.js]中,通常会为此使用一个库([Pinia]);而在[Angular]中,仅靠服务和信号就足够了。

5.2.2. 共享该状态的组件

// 20-shared-state/src/app/components/shop.ts - 向共享购物车添加商品
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 },
  ];
}
  • 第 17 行:组件注入该服务;
  • 第 11 行:它调用一个动作。
// 20-shared-state/src/app/components/cart-summary.ts - 读取同一个购物车
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);
}
  • 第 10 行:它从同一个服务中读取计算值;
  • 第 12 行:它调用另一个动作。

这两个组件彼此并不知道对方的存在:它们之间没有输入或输出。它们通过服务进行通信。

// 20-shared-state/src/app/components/local-counter.ts - 本地状态,随组件一起消失
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);
}
  • 第 14 行:一个本地状态:组件的每个实例都有自己的计数器,实例被销毁时计数器随之消失。

5.2.3. 在页面刷新后依然保留的状态

// =========================================================================
// 20-shared-state/src/app/state/preferences.service.ts - 在 F5 后依然保留的状态
// -------------------------------------------------------------------------
// 要让数据在页面重新加载或关闭
// 浏览器后依然保留,必须将其存储在浏览器中:localStorage(一个
// 小型的键 -> 字符串字典,每个站点各有一份)。
//   - 启动时,服务重新读取 localStorage;
//   - 每次变化时,由 effect 重写 localStorage。
// 绝不在其中存储敏感数据(密码、令牌):页面中的
// 任何脚本都可以读取 localStorage。
// =========================================================================

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

const KEY = 'example20.preferences';

export interface Preferences {
  dark: boolean;
  size: number; // 文字大小,单位 px
}

function read(): Preferences {
  try {
    return { dark: false, size: 16, ...JSON.parse(localStorage.getItem(KEY) ?? '{}') };
  } catch {
    return { dark: false, size: 16 }; // 内容不可读:使用默认值
  }
}

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

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

  // 偏好设置发生变化:替换整个对象(信号会察觉到)
  update(change: Partial<Preferences>): void {
    this.preferences.update((p) => ({ ...p, ...change }));
  }
}
  • 第 15 行:偏好设置在[localStorage]中存储时所使用的键,localStorage 是每个站点专属的小型“键到字符串”字典;
  • 第 22–28 行:启动时读取已保存的偏好设置。默认值由已保存的值补充(使用[...]运算符);无法读取的内容将被忽略(第 26 行);
  • 第 32 行:偏好设置,保存在一个信号中;
  • 第 35 行:一个effect(副作用)(示例 13)在信号每次变化时重写[localStorage] :你不必在每个动作中都考虑这件事;
  • 第 39–41 行:修改一个或多个偏好设置的动作([Partial<Preferences>]:每个属性都是可选的对象)。我们替换整个对象而不是修改它:信号只能检测到值的变化。

敏感数据(密码、登录令牌)绝不存储在[localStorage]中:页面执行的任何脚本都可以读取它。这就是为什么[RdvMedecins]应用的登录令牌将存储在 Cookie 中,而[JavaScript]代码无法访问 Cookie。

5.2.4. 页面

// =========================================================================
// 20-shared-state/src/app/app.ts - 客户端的三种数据“作用域”
// -------------------------------------------------------------------------
// 与 NestJS 课程的示例 23 是同一个问题(应用、
// 请求、客户端作用域),移植到浏览器中:
//   - 组件的本地(LOCAL)状态(LocalCounter)随组件一起消失;
//   - 根服务(SERVICE,即购物车)的状态由所有
//     组件共享,在它们被移除后依然存在——但 F5 后不会保留;
//   - 存储在 localStorage 中的状态(偏好设置)在 F5 和
//     关闭浏览器后依然保留。
// 取消勾选再重新勾选 "show the area",然后重新加载页面:对比一下。
// =========================================================================

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);
}
  • 第 27 行:根组件的本地状态:该区域是否显示?
@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>
  • 第 1 行:[@let] 声明一个模板变量:[p] 避免重复书写[prefs.preferences()];
  • 第 2 行:偏好设置应用于整个页面:[[class.bg-dark]] 在值为 true 时设置该类;[[style.font-size.px]] 设置以像素为单位的大小;
  • 第 7–8 行和第 12–13 行:每次更改都会触发动作[update];
  • 第 20–26 行:包含这三个组件的区域,无论是否显示;
  • 第 28 行:同一购物车的第二个摘要,位于该区域之外。

[npm start 20-shared-state];向购物车中添加两件商品,并点击本地计数器两次:

Image

然后你可以验证这三种作用域:

  • 取消勾选再重新勾选“显示该区域”:本地计数器已重置为 0(组件被重新创建),购物车保持完好(服务依然存在);
  • 选择深色主题,然后重新加载页面(F5):购物车为空(应用已重新启动),深色主题被保留([localStorage] 依然存在)。