6. 异步操作与共享状态
6.1. 示例 19:Promise、Observable 与定时器
许多事情都发生在“稍后”:定时器的触发、按键以及服务器的响应。[Ionic] 应用程序为此有两种类型:
- [Promise<T>],即 [JavaScript] 的那个:稍后得到一个(ONE)值(服务器响应、在窗口中做出的选择)。关键字 [async] 和 [await] 使你可以等待它而不阻塞应用程序。这相当于 [Future] 在 [Dart] 中的对应物;
- [Observable<T>],它来自 [RxJS] 库,随 [Angular] 一起提供:一个随时间推移的值的序列(SEQUENCE)(定时器触发、按键、消息……),这些值由操作符 ([map]、[take]、[debounceTime]、[switchMap]……)进行转换。这相当于 [Stream] 在 [Dart] 中的对应物。[JavaScript] 也有它自己的异步对应物:异步生成器 ([async function*]),它们对应于 [async*] 函数(来自 [Dart])。
为了显示它们,[Angular] 提供了三种工具,对应于 [FutureBuilder] 和 [StreamBuilder]:管道 [async](从模板中读取的 [Observable] )、[toSignal()] (转换为信号的 [Observable] )和 [resource()](转换为信号的 [Promise] )。而对于必须在延迟之后发生的事情:[setTimeout],或来自 [RxJS] 的定时器([timer]、[interval])。
6.1.1. 页面
| // =========================================================================
// src/app/ex19-asynchronous/ex19.page.ts - promise、observable、定时器
// -------------------------------------------------------------------------
// 许多事情都发生在“稍后”:定时器的触发、
// 按键、服务器的响应。有两种类型可用:
// - Promise(JavaScript):稍后得到一个(ONE)值(服务器的
// 响应);用 async / await 等待它;
// - Observable(RxJS 库,随 Angular 一起提供):一个随时间推移的值的
// 序列(SEQUENCE)(定时器触发、按键……),我们用
// “操作符”(map、take、debounceTime、switchMap……)转换它。
// 为了显示它们,Angular 提供了 async 管道(模板中的 Observable)、
// toSignal()(把 Observable 变成信号)和 resource()(把
// Promise 变成信号)。
// =========================================================================
import { AsyncPipe } from '@angular/common';
import { Component, resource, signal } from '@angular/core';
import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
import {
IonBackButton, IonButtons, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonContent, IonHeader, IonInput,
IonNote, IonTitle, IonToolbar,
} from '@ionic/angular';
import { debounceTime, finalize, from, map, Observable, of, Subject, switchMap, take, tap, timer } from 'rxjs';
const doctors = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];
// 以 Promise 形式出现的定时器:它在 ms 毫秒之后结束
function wait(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
// 一个模拟的“服务器”:响应(一个 Promise)在随机延迟之后到达
async function search(text: string): Promise<string[]> {
await wait(200 + Math.floor(Math.random() * 600));
return doctors.filter((m) => m.toLowerCase().includes(text));
}
// 1a. 一个异步生成器(ASYNCHRONOUS GENERATOR)(async function*,带星号):每个
// yield 都会向遍历它的一方(for await...of)发送(SENDS)一个值
async function* countdown(start: number): AsyncGenerator<number> {
for (let remaining = start; remaining >= 0; remaining--) {
yield remaining;
if (remaining > 0) await wait(1000);
}
}
// “15:30:45”
const currentTime = () => new Date().toTimeString().substring(0, 8);
@Component({
selector: 'app-ex19',
imports: [
AsyncPipe, IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle, IonContent, IonCard, IonCardHeader,
IonCardSubtitle, IonCardContent, IonInput, IonNote,
],
templateUrl: './ex19.page.html',
styles: `
.number { font-size: 2em; color: var(--ion-text-color); }
.log { font-size: 12px; }
`,
})
export class Ex19Page {
readonly log = signal<string[]>([]);
// 1a. 生成器,被 from() 转换为 Observable;模板
// 用 async 管道显示它。只在字段中创建一次(ONCE)
readonly countdown$: Observable<number> = from(countdown(20));
// 1b. 同样的倒计时,使用 RxJS 操作符:timer(0, 1000)
// 每秒发出 0、1、2……;take(21) 在 21 个值之后停止;
// map 转换这些值(0 -> 20,1 -> 19……)。toSignal:一个信号,其值是
// 最后收到的值(在第一个值之前为 undefined)
readonly countdown = toSignal(timer(0, 1000).pipe(take(21), map((i) => 20 - i)));
// 3. 一个在一秒后完成的 Promise,随后是 resource():
// 一个带有信号的对象(isLoading()、hasValue()、value()、error()……)
readonly message = resource({
loader: async () => {
await wait(1000);
return 'three (one second later)';
},
});
// 2. 边输入边搜索:Subject 是一个 Observable,我们自己
// 向其中推入(PUSH)值(next):这里是每一次按键
private readonly keystrokes = new Subject<string>();
readonly results = signal<string[]>([]);
constructor() {
this.keystrokes
.pipe(
// 防抖(DEBOUNCE):只有在 400 毫秒内没有
// 新的按键之后,才会传递一个值;间隔更近的按键会被忘掉
debounceTime(400),
map((text) => text.trim().toLowerCase()),
// switchMap:每个文本都会启动一次搜索(一个 Observable);
// 新的(NEW)搜索会放弃(ABANDONS)前一次搜索,其响应将
// 永远不会被传递:不会有“过期”响应
switchMap((text) => this.launch(text)),
// 订阅在页面被销毁时结束
takeUntilDestroyed(),
)
.subscribe((found) => this.results.set(found));
}
private trace(message: string): void {
this.log.update((lines) => [...lines, `${currentTime()} ${message}`]);
}
// 每次按键时调用
input(text: string | null | undefined): void {
this.keystrokes.next(text ?? '');
}
private launch(text: string): Observable<string[]> {
// 少于两个字母:不搜索,没有结果
if (text.length < 2) {
return of([]);
}
this.trace(`search sent: "${text}"`);
let received = false;
// from(Promise):一个 Observable,它发出 Promise 的值,然后完成
return from(search(text)).pipe(
tap(() => (received = true)),
// finalize:在 Observable 完成时,或在我们取消订阅时(OR)被调用
// (当新的搜索到来时,switchMap 就是这样做的)
finalize(() => {
if (!received) this.trace(`response ignored (stale): "${text}"`);
}),
);
}
}
|
| <!-- ======================================================================
ex19.page.html - promises, observables and timers
====================================================================== -->
<ion-header>
<ion-toolbar color="primary">
<ion-buttons slot="start">
<ion-back-button defaultHref="/" />
</ion-buttons>
<ion-title>Example 19 - asynchrony</ion-title>
</ion-toolbar>
</ion-header>
<ion-content class="ion-padding">
<ion-card>
<ion-card-header>
<ion-card-subtitle>Two countdowns (Observables)</ion-card-subtitle>
</ion-card-header>
<ion-card-content>
<!-- the async pipe subscribes to the Observable, displays each new
value, and unsubscribes when the page disappears; it is null
before the first value. @let: a template variable -->
@let n = countdown$ | async;
<p>async function* and async pipe: <span class="number">{{ n ?? '...' }}</span></p>
<!-- 信号:在第一个值之前为 undefined -->
<p>RxJS and toSignal(): <span class="number">{{ countdown() ?? '...' }}</span></p>
</ion-card-content>
</ion-card>
<ion-card>
<ion-card-header>
<ion-card-subtitle>A search as you type (debounce, stale responses)</ion-card-subtitle>
</ion-card-header>
<ion-card-content>
<!-- (ionInput):在每次按键时 -->
<ion-input placeholder="at least two letters: pel, dur..." (ionInput)="input($event.detail.value)" />
@for (r of results(); track r) {
<p>• {{ r }}</p>
} @empty {
<ion-note>no result</ion-note>
}
</ion-card-content>
</ion-card>
<ion-card>
<ion-card-header>
<ion-card-subtitle>Waiting for a Promise (resource)</ion-card-subtitle>
</ion-card-header>
<ion-card-content>
<!-- 只要 Promise 尚未完成:显示等待内容 -->
@if (message.hasValue()) {
<p>received: {{ message.value() }}</p>
} @else {
<ion-note>waiting...</ion-note>
}
</ion-card-content>
</ion-card>
<h6>Log</h6>
@for (line of log(); track $index) {
<div class="log">{{ $index + 1 }}. {{ line }}</div>
}
</ion-content>
|
工具:
- 第 28–30 行(.ts):以 [Promise] 形式出现的定时器。[new Promise(...)] 接收一个启动任务的函数,任务完成时它会调用 [resolve] ;这里,[setTimeout] 在 [ms] 毫秒之后调用它。因此 [await wait(1000)] 会等待一秒而不阻塞应用程序(对应 [Future.delayed] ,来自 [Dart]);
- 第 33–36 行(.ts):一个模拟的“服务器”:一个 [async] 函数,它返回一个 [Promise];它的响应在随机延迟(200 到 800 毫秒之间)后到达;
- 第 40–45 行(.ts):一个异步生成器:一个 [async function*] 函数(带星号)。每个 [yield] 都会把一个值交给遍历该生成器的一方;在两个值之间,函数等待一秒。可以用循环 [for await (const n of countdown(20))] 来遍历它。
第一个倒计时:
- 第 67 行(.ts):生成器,通过 [Observable] 被 [from()] 转换,它接受异步生成器、[Promise]、数组……按照惯例,包含 [Observable] 的变量,其名称以 [$] 结尾;
- 第 23 行(HTML):管道 [async] 订阅 [Observable],显示每个新值,并在页面关闭时自动取消订阅;在收到第一个值之前,它为 [null] 。[@let n = ...] 声明一个模板变量,在第 24 行读取([n ?? '...']:只要 [n] 等于 [null],就显示三个点)。与 [Flutter] 一样,[Observable] 只在类字段中创建一次(ONCE):如果模板调用一个创建它的方法,每次屏幕更新都会重新开始倒计时!
第二个,使用 [RxJS] 操作符:
- 第 73 行(.ts):[timer(0, 1000)] 立即输出 0,然后每秒输出 1、2、3……;[pipe] 方法依次对它应用各个操作符:[take(21)] 只保留前 21 个值(然后 [Observable] 结束);[map] 转换每个值(0 变为 20,1 变为 19……)。[toSignal] 订阅 [Observable] 并把它变成一个信号,其值等于最后收到的值(在第一个值之前为 [undefined] );页面被销毁时它会取消订阅;
- 第 26 行(HTML):像读取任何其他信号一样读取该信号。
预期的 [Promise]:
- 第 77–82 行(.ts):[resource()] 接收一个返回 [loader] 的 [Promise] 函数,调用它,并把它的状态以信号的形式公开:[isLoading()]、[hasValue()]、[value()]、[error()]。如果我们提供一个选项 [params]——一个读取信号的函数——那么每当这些信号变化时,资源就会重新加载(而 [loader] 则不会被监视):我们将用它来查询服务器;
- 第 51–55 行(HTML):在 [Promise] 尚未完成时,显示占位内容;完成之后,显示它的值(这对应于 [FutureBuilder] 和 [ConnectionState.done])。
边输入边搜索:
- 第 86 行(.ts):[Subject] 是一个 [Observable] ,我们自己向其中推入(PUSH)值([next]):这里是每一次按键(第 111–113 行,由字段的 [(ionInput)] 事件触发,见 HTML 的第 36 行);
- 第 94 行(.ts):防抖:我们等待用户停顿之后再查询服务器,而不是对每次按键都发送请求。[debounceTime(400)] 操作符只在 400 毫秒内没有新值之后才发出一个值:间隔太近的按键会被忽略。使用 [Flutter] 时,你必须在每次按键时手动取消并重新启动一个定时器([Timer]);
- 第 95 行(.ts):文本,去掉两端的空格,并转为小写;
- 第 99 行(.ts):过期响应。在另一次搜索已经发起之后(AFTER)才到达的响应必须被忽略:否则,旧搜索的慢响应会覆盖新搜索的响应。操作符 [switchMap] 处理这个问题:对于每个文本,它调用 [launch],后者返回一个 [Observable] (即该搜索);当新文本到达时,它会取消订阅(UNSUBSCRIBES),取消前一次搜索——其响应将永远不会被传递——然后发起新的搜索。使用 [Flutter] 时,则必须给搜索编号并比较编号;
- 第 101 行(.ts):[takeUntilDestroyed()] 在页面被销毁时终止订阅:没有它,[Subject] 及其操作符会继续存在(在 [dispose] 中对应于 [Flutter] 的做法)。它必须在“注入上下文”中调用:在这里就是构造函数;
- 第 103 行(.ts):[subscribe] 订阅 [Observable]:在有人订阅之前什么也不会发生。每个结果列表都存储在一个信号中,由模板显示(HTML 的第 37–41 行);
- 第 117–119 行(.ts):少于两个字母:不搜索;[of([])] 是一个立即返回空列表的 [Observable] ;
- 第 123–130 行(.ts):搜索:服务器的 [Promise],被 [from()] 转换为 [Observable]。[tap] 顺带执行一个操作而不修改值:记录响应已到达。[finalize] 在 [Observable] 终止时,或用户取消订阅时被调用:如果响应没有到达,就说明 [switchMap] 放弃了这次搜索,并把这一点记入日志。
我们快速输入“p”、“pe”和“pel”:只会发送一次搜索。然后输入“du”,在“du”的响应到达之前又输入“dup”:在发送“dup”的搜索的那一刻,“du”的搜索就被放弃了(它的响应被忽略)。左图是页面刚打开时的样子;右图是五秒之后:
在日志中,“response ignored”这一行出现在“search sent: ‘dup’”这一行之前:[switchMap] 在发起新搜索之前先取消了对旧搜索的订阅。
在 [Dart] 中,[Future] 和 [Stream] 位于基础库中,而 [async]、[await]、[async*]、[yield] 和 [await for] 属于语言本身。在 [JavaScript] 中,[Promise]、[async]、[await] 和异步生成器同样包含在语言中;但对于值序列,[Angular] 依赖 [RxJS] 库,它的上百个操作符可以用一行代码解决防抖和过期响应之类的问题。[Angular] 的 HTTP 客户端(示例 22 至 25)同样返回 [Observable]。自从有了信号,[Angular] 只把 [RxJS] 留给事件流,并使用 [toSignal] 或 [resource] 来显示它们。
6.2. 示例 20:共享状态
与前面几课相同的问题:应用程序数据有哪些“作用域”?
- 组件的局部状态在组件被销毁时消失;
- “store”的状态由所有组件共享,并且在它们被移除后依然存在……但不会在应用程序关闭后保留;
- 存储在设备上的状态在应用程序关闭后依然存在。
6.2.1. 购物车
| // =========================================================================
// src/app/ex20-shared-state/stores/cart.ts - 一个共享状态(SHARED STATE):一个服务
// -------------------------------------------------------------------------
// “store”是一种存在于页面和组件之外(OUTSIDE)的状态,
// 以唯一(ONE)一个实例存在,由所有读取它的一方共享。
// 在 Angular 中,它是一个服务(SERVICE)(见示例 14),其状态由
// 信号(SIGNALS)构成。通常的组织方式:
// - 状态(STATE):私有(PRIVATE)信号(_items);
// - 它们的读取:只读视图(asReadonly);
// - 操作(ACTIONS):方法,是唯一修改状态的部分;
// - 计算值:computed 信号。
// 组件通过 inject(Cart) 获得它;读取这些信号的
// 模板会在它们(THEY)变化时更新,而且只在它们变化时更新。
// providedIn: 'root':服务在第一次被请求时创建,并在
// 应用程序运行期间一直存在:它在组件被移除后依然存在……但
// 不会在应用程序停止后保留。
// =========================================================================
import { computed, Injectable, signal } from '@angular/core';
export interface Item {
label: string;
price: number;
}
@Injectable({ providedIn: 'root' })
export class Cart {
private readonly _items = signal<Item[]>([]);
// 状态的不可修改(NON-MODIFIABLE)视图:只有这些操作才能改变它
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 {
// 一个新的(NEW)数组:信号会发现它的值已经变化
this._items.update((items) => [...items, item]);
}
clear(): void {
this._items.set([]);
}
}
|
store 是一种跨越页面和组件的状态,作为单个实例存在,由所有访问它的一方共享。使用 [Angular] 时,它就是一个服务 (见示例 14),其状态由信号组成:无需添加任何库,而 [Flutter] 则是围绕 [ChangeNotifier] 使用 [provider] 包。
- 第 26 行:[providedIn: 'root']:服务在第一次被请求([inject(Cart)])时创建,作为单个实例存在,并在应用程序运行期间一直保持活动;
- 第 28 行:状态:一个私有信号;
- 第 30 行:状态的只读视图([asReadonly()]):只有操作(action)才能修改它;
- 第 31–32 行:计算值:[computed] 信号,只在商品列表变化时才重新计算;
- 第 34–41 行:操作:只有这些方法才会修改状态。第 36 行:一个新的(NEW)数组([...items] 复制各商品),而不是像旧版本那样使用 [push]:信号会比较新旧值([===]),只有在它们不同时才通知订阅者。无需编写 [notifyListeners()]:信号会负责通知。
6.2.2. 偏好设置
| // =========================================================================
// src/app/ex20-shared-state/stores/preferences.ts - 在应用停止后依然存在的状态
// -------------------------------------------------------------------------
// 要让一份数据在应用程序停止后依然存在,就必须把它存储
// 在设备上(ON THE DEVICE)。@capacitor/preferences “插件”提供了一个小型的
// 键 -> 值字典(字符串),专属于该应用程序并
// 保存在设备上(Android:SharedPreferences;在
// 浏览器中:localStorage)。它的所有方法都是异步的(ASYNCHRONOUS)
// (它们返回一个 Promise):
// - 启动时,我们读取存储的值;
// - 每次变化时,我们再次写入它们。
// 我们绝不(NEVER)在这里存储敏感数据(密码、令牌):它们是
// 以明文写入的。
// =========================================================================
import { effect, Injectable, signal } from '@angular/core';
// “as DeviceStorage”:已重命名,以免与我们自己的类混淆
import { Preferences as DeviceStorage } from '@capacitor/preferences';
const darkKey = 'example20.dark';
const sizeKey = 'example20.size';
@Injectable({ providedIn: 'root' })
export class Preferences {
// 初始状态:默认值,等待读取完成
private readonly _dark = signal(false);
private readonly _size = signal(16); // 文本大小
readonly dark = this._dark.asReadonly();
readonly size = this._size.asReadonly();
constructor() {
this.load();
// 一个副作用(EFFECT):每当它读取的某个信号变化时就会重新执行的函数。
// 它把偏好设置应用于整个(WHOLE)应用程序:
// - <html> 上的 ion-palette-dark 类:Ionic 的深色主题
// (见 styles.scss);
// - <html> 的字体大小:Ionic 的组件
// 以 rem(该大小的倍数)表示尺寸,因此它们会随之变化
effect(() => {
document.documentElement.classList.toggle('ion-palette-dark', this._dark());
document.documentElement.style.fontSize = `${this._size()}px`;
});
}
// 设备上存储的内容(如果键不存在,value 为 null)
private async load(): Promise<void> {
const dark = await DeviceStorage.get({ key: darkKey });
const size = await DeviceStorage.get({ key: sizeKey });
if (dark.value !== null) this._dark.set(dark.value === 'true');
if (size.value !== null) this._size.set(Number(size.value));
}
// 每项偏好设置一个可选参数:我们只更改所提供的内容
update({ dark, size }: { dark?: boolean; size?: number }): void {
if (dark !== undefined) {
this._dark.set(dark);
DeviceStorage.set({ key: darkKey, value: String(dark) }); // 写入设备
}
if (size !== undefined) {
this._size.set(size);
DeviceStorage.set({ key: sizeKey, value: String(size) });
}
}
}
|
要让数据在应用程序关闭后仍然保留,就必须把它存储在设备上。[@capacitor/preferences] “插件”来自 [Capacitor] ,它提供一个小型的键值字典(字符串),专属于该应用程序并存储在设备上:在 [SharedPreferences] (来自 [Android] ,即 [shared_preferences] 包(来自 [Flutter])所使用的那个)上实现,而在浏览器中则使用 [localStorage]。它的所有方法都是异步的:它们返回一个 [Promise]。
- 第 18 行:该插件本身也叫 [Preferences];[as DeviceStorage] 在此文件中重命名它,以避免与我们自己的类混淆;
- 第 26–29 行:初始状态,各信号设为默认值,以及它们的只读视图;
- 第 32 行:服务创建时开始读取设备。读取是异步的:在短暂的片刻内,默认值生效;
- 第 39–42 行:一个副作用 ([effect]):每当它读取的某个信号变化时就会重新执行的函数。它把偏好设置应用于整个(WHOLE)应用程序:[<html>] 标签上的 CSS 类 [ion-palette-dark] 会激活 [Ionic] 中的深色主题(定义在 [styles.scss] 中);[<html>] 中的字体大小会放大文本,因为 [Ionic] 的组件以 [rem] (该大小的倍数)来表示它们的尺寸。副作用就是为此而设:把信号传递给外部世界(DOM、存储等);不得用它来计算其他信号([computed] 就是为此设计的);
- 第 46–51 行:设备读取操作:[DeviceStorage.get] 返回一个来自 [Promise] 的 [{ value }],其中如果键不存在,[value] 等于 [null] 。这些值是字符串:需要进行转换;
- 第 54–63 行:一个带可选参数的单一操作(一个解构对象:[{ dark, size }]):只修改所提供的值,并立即把它写入设备([DeviceStorage.set])。我们不等待写入操作完成:信号已经变化了。
切勿在这里存储敏感数据(密码、令牌):它是以明文写入的。为此,有一些使用系统保险库的插件([Keystore] 属于 [Android],[Keychain] 属于 [iOS])。
6.2.3. 组件
| // =========================================================================
// src/app/ex20-shared-state/components/shop.ts - 向共享购物车添加(ADDS)商品
// -------------------------------------------------------------------------
// 商店只是调用(CALLS)购物车的一个操作;它的模板不读取
// 购物车的任何信号:购物车变化时它不会更新。
// =========================================================================
import { CurrencyPipe } from '@angular/common';
import { Component, inject } from '@angular/core';
import { IonButton, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonIcon } from '@ionic/angular';
import { addIcons } from 'ionicons';
import { add } from 'ionicons/icons';
import { Item, Cart } from '../stores/cart';
const products: Item[] = [
{ label: 'Consultation', price: 30 },
{ label: 'Vaccine', price: 12.5 },
];
@Component({
selector: 'app-ex20-shop',
imports: [CurrencyPipe, IonCard, IonCardHeader, IonCardSubtitle, IonCardContent, IonButton, IonIcon],
templateUrl: './shop.html',
})
export class Shop {
readonly products = products;
// 与其他组件相同(SAME)的购物车(唯一的一个实例)
readonly cart = inject(Cart);
constructor() {
addIcons({ add });
}
}
|
| <!-- ======================================================================
shop.html - two products to add to the cart
====================================================================== -->
<ion-card>
<ion-card-header>
<ion-card-subtitle>Shop</ion-card-subtitle>
</ion-card-header>
<ion-card-content>
@for (p of products; track p.label) {
<ion-button fill="clear" (click)="cart.add(p)">
<ion-icon slot="start" name="add" />
{{ p.label }} ({{ p.price | currency: 'EUR' }})
</ion-button>
}
</ion-card-content>
</ion-card>
|
- 第 28 行(.ts):[inject(Cart)] 返回与其他组件相同的(SAME)购物车;
- 第 11 行(html):商店只是调用一个操作。它的模板不读取购物车中的任何信号:购物车变化时它不会更新(在 [context.read<Cart>()] 与 [provider] 中就是如此);
- 第 13 行(html):[currency] 管道以英式风格格式化价格(见示例 09)。
| // =========================================================================
// src/app/ex20-shared-state/components/cart-summary.ts - 读取(READS)同一个购物车
// -------------------------------------------------------------------------
// 模板读取购物车的两个信号,count() 和 total():只要其中
// 一个(ONE)变化就会更新,而且仅在此时更新。
// =========================================================================
import { CurrencyPipe } from '@angular/common';
import { Component, inject } from '@angular/core';
import { IonButton, IonCard, IonIcon, IonItem, IonLabel } from '@ionic/angular';
import { addIcons } from 'ionicons';
import { cart } from 'ionicons/icons';
import { Cart } from '../stores/cart';
@Component({
selector: 'app-ex20-cart-summary',
imports: [CurrencyPipe, IonCard, IonItem, IonIcon, IonLabel, IonButton],
templateUrl: './cart-summary.html',
})
export class CartSummary {
readonly cart = inject(Cart);
constructor() {
addIcons({ cart });
}
}
|
| <!-- ======================================================================
cart-summary.html - the number of items and the total of the cart
====================================================================== -->
<ion-card>
<ion-item lines="none">
<ion-icon slot="start" name="cart" />
<ion-label>{{ cart.count() }} item(s), {{ cart.total() | currency: 'EUR' }}</ion-label>
<ion-button slot="end" fill="clear" [disabled]="cart.count() === 0" (click)="cart.clear()">
Clear
</ion-button>
</ion-item>
</ion-card>
|
- 第 8–9 行(HTML):模板读取购物车中的两个信号,[count()] 和 [total()]:只要其中任何一个变化,它就会更新,而且仅在此时更新。使用 [provider] 时,你必须在 [context.watch] (整个购物车)和 [context.select] (单个项目)之间做选择;而有了信号,精确度是自动的:它取决于所读取的内容。
| // =========================================================================
// src/app/ex20-shared-state/components/local-counter.ts - 一个局部状态(LOCAL)
// -------------------------------------------------------------------------
// clicks 信号属于该组件:它随组件一起创建,也随组件一起
// 消失。
// =========================================================================
import { Component, input, signal } from '@angular/core';
import { IonButton, IonCard, IonItem, IonLabel } from '@ionic/angular';
@Component({
selector: 'app-ex20-local-counter',
imports: [IonCard, IonItem, IonLabel, IonButton],
templateUrl: './local-counter.html',
})
export class LocalCounter {
readonly title = input.required<string>();
readonly clicks = signal(0);
}
|
| <!-- ======================================================================
local-counter.html - a click counter
====================================================================== -->
<ion-card>
<ion-item lines="none">
<ion-label>{{ title() }}</ion-label>
<ion-button slot="end" fill="outline" (click)="clicks.set(clicks() + 1)">{{ clicks() }} click(s)</ion-button>
</ion-item>
</ion-card>
|
一个局部状态(.ts 文件的第 18 行),它随组件一起创建和销毁。
6.2.4. 页面
| // =========================================================================
// src/app/ex20-shared-state/ex20.page.ts - 数据的三种“作用域”
// -------------------------------------------------------------------------
// - 组件(LocalCounter)的局部状态(LOCAL)随组件一起消失;
// - 服务(购物车)的状态(SERVICE)由所有组件共享,
// 并在它们被移除后依然存在——但不会在应用程序停止后保留;
// - 存储在设备上的状态(偏好设置)在应用停止后依然存在。
// 还有 CSS 类 ion-hide:内容被隐藏(HIDDEN),但没有被移除;它的
// 局部状态得以保留。
// 取消勾选再重新勾选“显示该区域”,然后停止并重新启动
// 应用程序:比较一下。
// =========================================================================
import { Component, inject, signal } from '@angular/core';
import {
IonBackButton, IonButtons, IonCheckbox, IonContent, IonHeader, IonItem, IonLabel, IonList, IonRange, IonTitle,
IonToggle, IonToolbar,
} from '@ionic/angular';
import { Shop } from './components/shop';
import { LocalCounter } from './components/local-counter';
import { CartSummary } from './components/cart-summary';
import { Preferences } from './stores/preferences';
@Component({
selector: 'app-ex20',
imports: [
IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle, IonContent, IonList, IonItem, IonLabel, IonToggle,
IonRange, IonCheckbox, Shop, CartSummary, LocalCounter,
],
templateUrl: './ex20.page.html',
})
export class Ex20Page {
readonly preferences = inject(Preferences);
// 页面的一个局部状态
readonly areaVisible = signal(true);
}
|
| <!-- ======================================================================
ex20.page.html - a shared state
====================================================================== -->
<ion-header>
<ion-toolbar color="primary">
<ion-buttons slot="start">
<ion-back-button defaultHref="/" />
</ion-buttons>
<ion-title>Example 20 - a shared state</ion-title>
</ion-toolbar>
</ion-header>
<ion-content class="ion-padding">
<ion-list>
<ion-item>
<!-- [checked]:服务的值;(ionChange):修改它的操作 -->
<ion-toggle [checked]="preferences.dark()"
(ionChange)="preferences.update({ dark: $event.detail.checked })">dark theme</ion-toggle>
</ion-item>
<ion-item>
<!-- snaps / ticks:刻度,每一步一个 -->
<ion-range [min]="12" [max]="22" [step]="1" [snaps]="true" [ticks]="true" [value]="preferences.size()"
(ionChange)="preferences.update({ size: +$event.detail.value })">
<ion-label slot="label">text size: {{ preferences.size() }}</ion-label>
</ion-range>
</ion-item>
<ion-item>
<ion-checkbox [checked]="areaVisible()" (ionChange)="areaVisible.set($event.detail.checked)">
show the area</ion-checkbox>
</ion-item>
</ion-list>
<!-- 已移除:这些组件消失,连同它们的局部状态 -->
@if (areaVisible()) {
<app-ex20-shop />
<app-ex20-cart-summary />
<app-ex20-local-counter title="Local state" />
}
<!-- 已隐藏(ion-hide:display none):组件仍保留在内存中,它的状态得以保留 -->
<app-ex20-local-counter title="Local state, hidden by a CSS class" [class.ion-hide]="!areaVisible()" />
<p>Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
<app-ex20-cart-summary />
</ion-content>
|
- 第 33 行(.ts):偏好设置,一个服务;它在第一次被请求时创建(并读取设备);
- 第 35 行(.ts):页面的一个局部状态:该区域是否显示?
- 第 18–19 行(html):一个切换开关([<ion-toggle>]):[[checked]] 从服务接收值,而 [(ionChange)] 调用服务的操作;
- 第 23–26 行(html):一个取值范围为 12 到 22 的滑块([<ion-range>]),带有刻度标记([snaps]、[ticks]);[+$event.detail.value] 把值转换为数字;
- 第 29–30 行(html):一个复选框,与局部状态相连;
- 第 35–39 行(HTML):被移除([@if]);该区域消失——它的组件连同其局部状态一起被销毁(DESTROYED);
- 第 41 行(html):通过 [ion-hide] 这个来自 [Ionic] 的 CSS 类([display: none])隐藏;组件仍保留在内存中:它的状态得以保留。[[class.ion-hide]="..."] 在表达式为 true 时设置该类。(这在以前是 [Visibility(maintainState: true)] ,来自 [Flutter]。)
- 第 44 行(html):同一购物车的第二个摘要,位于该区域之外。
购物车和偏好设置在整个应用程序中共享([providedIn: 'root'])。要让服务专属于某个页面(每个页面一个实例,随页面一起销毁),需要把它声明在其组件的 [providers] 中,如示例 21 所示。
6.2.5. 运行
我们添加两件商品,点击第一个局部计数器两次、第二个一次(左图);我们移除该区域并切换到深色主题(中图);然后恢复该区域(右图):
购物车在该区域被移除后依然存在(如第二个摘要所示);被移除的计数器重置为零;被隐藏的计数器保留了它的值。停止应用程序并重新启动它(在浏览器中:重新加载页面):深色主题和文字大小得以保留,而购物车是空的。偏好设置作用于整个应用程序:当你回到菜单时,它也处于深色模式。
为什么不使用状态管理库?[Angular] 有一些可用的库([NgRx]、它的变体 [SignalStore]、[NGXS]……),就像 [Flutter] 也有([provider]、[Riverpod]、[Bloc]……)一样。但依赖注入和信号已经解决了最关键的部分:基于信号的服务就是一个 store,而案例研究将使用它。