6. Operaciones asíncronas y estado compartido
6.1. Ejemplo 19: promesas, observables y temporizadores
Muchas cosas suceden “más tarde”: los ticks de un temporizador, las pulsaciones de teclas y las respuestas del servidor. Una aplicación [Ionic] tiene dos tipos para esto:
- [Promise<T>], el de [JavaScript]: UN valor, más tarde (una respuesta del servidor, una selección hecha en una ventana). Las palabras clave [async] y [await] permiten esperarlo sin bloquear la aplicación. Es el [Future] de [Dart];
- [Observable<T>], que proviene de la biblioteca [RxJS], incluida con [Angular]: una SECUENCIA de valores, a lo largo del tiempo (ticks, pulsaciones de teclas, mensajes...), que se transforman mediante operadores ([map], [take], [debounceTime], [switchMap]...). Es el [Stream] derivado de [Dart]. [JavaScript] también tiene sus equivalentes asíncronos: los generadores asíncronos ([async function*]), que son los equivalentes de las funciones [async*] de [Dart].
Para mostrarlos, [Angular] ofrece tres herramientas, equivalentes de [FutureBuilder] y [StreamBuilder]: el pipe [async] (un [Observable] leído desde la plantilla), [toSignal()] (un [Observable] convertido en signal) y [resource()] (una [Promise] convertida en signals). Y para lo que debe ocurrir después de un retraso: [setTimeout], o los temporizadores de [RxJS] ([timer], [interval]).
6.1.1. La página
| // =========================================================================
// src/app/ex19-asynchronous/ex19.page.ts - promesas, observables, temporizadores
// -------------------------------------------------------------------------
// Muchas cosas ocurren "más tarde": los ticks de un temporizador, las
// pulsaciones de teclas, la respuesta de un servidor. Hay dos tipos disponibles:
// - Promise (JavaScript): UN valor, más tarde (la respuesta de un
// servidor); async / await para esperarlo;
// - Observable (biblioteca RxJS, incluida con Angular): una SECUENCIA de
// valores, a lo largo del tiempo (ticks, pulsaciones...), que se transforman
// con "operadores" (map, take, debounceTime, switchMap...).
// Para mostrarlos, Angular ofrece el pipe async (un Observable en la
// plantilla), toSignal() (un Observable convertido en señal) y resource() (una
// Promise convertida en señal).
// =========================================================================
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'];
// un temporizador en forma de Promise: termina después de ms milisegundos
function wait(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
// un "servidor" simulado: la respuesta (una Promise) llega después de un retraso aleatorio
async function search(text: string): Promise<string[]> {
await wait(200 + Math.floor(Math.random() * 600));
return doctors.filter((m) => m.toLowerCase().includes(text));
}
// 1a. un GENERADOR ASÍNCRONO (async function*, con asterisco): cada
// yield ENVÍA un valor a quien lo itera (for await...of)
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. el generador, convertido en Observable por from(); la plantilla
// lo muestra con el pipe async. Creado UNA SOLA VEZ, en un campo
readonly countdown$: Observable<number> = from(countdown(20));
// 1b. la misma cuenta regresiva, con operadores RxJS: timer(0, 1000)
// emite 0, 1, 2... cada segundo; take(21) se detiene tras 21 valores;
// map los transforma (0 -> 20, 1 -> 19...). toSignal: una señal cuyo valor es
// el último valor recibido (undefined antes del primero)
readonly countdown = toSignal(timer(0, 1000).pipe(take(21), map((i) => 20 - i)));
// 3. una Promise que termina después de un segundo, seguida de resource():
// un objeto con señales (isLoading(), hasValue(), value(), error()...)
readonly message = resource({
loader: async () => {
await wait(1000);
return 'three (one second later)';
},
});
// 2. la búsqueda mientras se escribe: un Subject es un Observable en el
// que EMPUJAMOS los valores nosotros mismos (next): aquí, cada pulsación de tecla
private readonly keystrokes = new Subject<string>();
readonly results = signal<string[]>([]);
constructor() {
this.keystrokes
.pipe(
// el DEBOUNCE: un valor solo se transmite después de 400 ms sin
// una nueva pulsación; las pulsaciones más cercanas se olvidan
debounceTime(400),
map((text) => text.trim().toLowerCase()),
// switchMap: cada texto inicia una búsqueda (un Observable); una
// NUEVA búsqueda ABANDONA la anterior, cuya respuesta
// nunca se transmitirá: ninguna respuesta "obsoleta"
switchMap((text) => this.launch(text)),
// la suscripción termina cuando se destruye la página
takeUntilDestroyed(),
)
.subscribe((found) => this.results.set(found));
}
private trace(message: string): void {
this.log.update((lines) => [...lines, `${currentTime()} ${message}`]);
}
// llamado en cada pulsación de tecla
input(text: string | null | undefined): void {
this.keystrokes.next(text ?? '');
}
private launch(text: string): Observable<string[]> {
// menos de dos letras: sin búsqueda, sin resultado
if (text.length < 2) {
return of([]);
}
this.trace(`search sent: "${text}"`);
let received = false;
// from(Promise): un Observable que emite el valor de la Promise y luego se completa
return from(search(text)).pipe(
tap(() => (received = true)),
// finalize: llamado cuando el Observable se completa O cuando nos damos de baja de él
// (eso es lo que hace switchMap cuando llega una nueva búsqueda)
finalize(() => {
if (!received) this.trace(`response ignored (stale): "${text}"`);
}),
);
}
}
|
| <!-- ======================================================================
ex19.page.html - promesas, observables y temporizadores
====================================================================== -->
<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>
<!-- el pipe async se suscribe al Observable, muestra cada nuevo
valor, y cancela la suscripción cuando la página desaparece; es null
antes del primer valor. @let: una variable de plantilla -->
@let n = countdown$ | async;
<p>async function* and async pipe: <span class="number">{{ n ?? '...' }}</span></p>
<!-- la señal: undefined antes del primer valor -->
<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): en cada pulsación de tecla -->
<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>
<!-- mientras la Promise no haya terminado: el contenido de espera -->
@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>
|
Herramientas:
- líneas 28–30 (.ts): un temporizador en forma de [Promise]. [new Promise(...)] recibe una función que inicia la tarea y llamará a [resolve] cuando termine; aquí, [setTimeout] la llama después de [ms] milisegundos. [await wait(1000)] espera, por lo tanto, un segundo, sin bloquear la aplicación (esto era [Future.delayed] con [Dart]);
- líneas 33–36 (.ts): un “servidor” simulado: una función [async], que devuelve una [Promise]; su respuesta llega después de un retraso aleatorio (entre 200 y 800 milisegundos);
- líneas 40–45 (.ts): un generador asíncrono: una función [async function*] (con un asterisco). Cada [yield] entrega un valor a quien recorre el generador; entre dos valores, la función espera un segundo. Se puede recorrer mediante un bucle [for await (const n of countdown(20))].
La primera cuenta regresiva:
- línea 67 (.ts): el generador, convertido en [Observable] mediante [from()], que acepta un generador asíncrono, una [Promise], un arreglo... Por convención, el nombre de una variable que contiene un [Observable] termina con [$];
- Línea 23 (HTML): el pipe [async] se suscribe al [Observable], muestra cada nuevo valor y cancela la suscripción automáticamente cuando se cierra la página; vale [null] antes de recibir el primer valor. [@let n = ...] declara una variable de plantilla, leída en la línea 24 ([n ?? '...']: tres puntos mientras [n] sea igual a [null]). Como con [Flutter], el [Observable] se crea UNA SOLA VEZ en un campo de la clase: si la plantilla llamara a un método que lo creara, ¡cada actualización de la pantalla reiniciaría la cuenta regresiva!
La segunda, con los operadores de [RxJS]:
- línea 73 (.ts): [timer(0, 1000)] emite 0 de inmediato y luego 1, 2, 3... cada segundo; el método [pipe] le aplica operadores, uno tras otro: [take(21)] conserva solo los primeros 21 valores (luego el [Observable] termina); [map] transforma cada valor (0 se convierte en 20, 1 en 19...). [toSignal] se suscribe al [Observable] y lo convierte en una signal, que es igual al último valor recibido ([undefined] antes del primero); cancela la suscripción cuando se destruye la página;
- línea 26 (HTML): la signal se lee como cualquier otra signal.
La [Promise] esperada:
- líneas 77–82 (.ts): [resource()] recibe una función [loader] que devuelve una [Promise], la invoca y expone su estado como signals: [isLoading()], [hasValue()], [value()], [error()]. Si proporcionáramos una opción [params]—una función que lee signals—, el recurso se recargaría cada vez que estas cambien (el [loader], en cambio, no se monitorea): la usaremos para consultar un servidor;
- líneas 51–55 (HTML): mientras la [Promise] no haya terminado, el contenido provisional; después, su valor (esto era [FutureBuilder] y [ConnectionState.done]).
Búsqueda mientras se escribe:
- línea 86 (.ts): un [Subject] es un [Observable] al que nosotros mismos EMPUJAMOS los valores ([next]): aquí, cada pulsación de tecla (líneas 111–113, activadas por el evento [(ionInput)] del campo, línea 36 del HTML);
- línea 94 (.ts): antirrebote (debouncing): esperamos a que el usuario haga una pausa antes de consultar al servidor, en lugar de enviar una solicitud por cada pulsación de tecla. El operador [debounceTime(400)] solo emite un valor después de 400 milisegundos sin un nuevo valor: las pulsaciones demasiado seguidas se ignoran. Con [Flutter], había que cancelar y reiniciar manualmente un temporizador ([Timer]) con cada pulsación de tecla;
- línea 95 (.ts): el texto, sin espacios alrededor, en minúsculas;
- línea 99 (.ts): respuestas caducadas. Una respuesta que llega DESPUÉS de que se haya lanzado otra búsqueda debe ignorarse: de lo contrario, la respuesta lenta de una búsqueda antigua sobrescribiría la de la nueva. El operador [switchMap] se encarga de esto: para cada texto, llama a [launch], que devuelve un [Observable] (la búsqueda); cuando llega un nuevo texto, CANCELA LA SUSCRIPCIÓN, anulando la búsqueda anterior —cuya respuesta nunca se transmitirá— y luego lanza la nueva. Con [Flutter], era necesario numerar las búsquedas y comparar los números;
- Línea 101 (.ts): [takeUntilDestroyed()] finaliza la suscripción cuando se destruye la página: sin él, [Subject] y sus operadores seguirían existiendo (era el [dispose] de [Flutter]). Debe llamarse dentro de un “contexto de inyección”: en este caso, el constructor;
- línea 103 (.ts): [subscribe] se suscribe al [Observable]: no pasa nada hasta que alguien se suscribe. Cada lista de resultados se almacena en una signal, que la plantilla muestra (líneas 37–41 del HTML);
- líneas 117–119 (.ts): menos de dos letras: no hay búsqueda; [of([])] es un [Observable] que devuelve de inmediato una lista vacía;
- líneas 123–130 (.ts): la búsqueda: la [Promise] del servidor, transformada en [Observable] mediante [from()]. [tap] realiza una acción de paso, sin modificar el valor: anota que la respuesta ha llegado. [finalize] se invoca cuando el [Observable] termina, o cuando el usuario cancela su suscripción: si la respuesta no llegó, significa que [switchMap] abandonó esta búsqueda, y esto se registra en el log.
Escribimos “p”, “pe” y “pel” rápidamente: se envía una sola búsqueda. Luego “du”, seguido de “dup” antes de que llegue la respuesta a “du”: la búsqueda de “du” se abandona (su respuesta se ignora) en el momento en que se envía la búsqueda de “dup”. A la izquierda, la página al abrirse; a la derecha, cinco segundos después:
En el log, la línea “response ignored” precede a la línea “search sent: ‘dup’”: [switchMap] cancela la suscripción a la búsqueda antigua antes de lanzar la nueva.
En [Dart], [Future] y [Stream] están en la biblioteca base, y [async], [await], [async*], [yield] y [await for] están en el lenguaje. En [JavaScript], [Promise], [async], [await] y los generadores asíncronos también forman parte del lenguaje; pero para las secuencias de valores, [Angular] se apoya en la biblioteca [RxJS], cuyos cien o más operadores resuelven problemas como el antirrebote y las respuestas caducadas en una sola línea. El cliente HTTP de [Angular] (ejemplos 22 a 25) también devuelve [Observable]. Desde la llegada de las signals, [Angular] reserva [RxJS] para los flujos de eventos y usa [toSignal] o [resource] para mostrarlos.
6.2. Ejemplo 20: un estado compartido
La misma pregunta que en las lecciones anteriores: ¿cuáles son los “ámbitos” de los datos de una aplicación?
- El estado local de un componente desaparece cuando el componente se destruye;
- el estado de un “store” es compartido por todos los componentes y sobrevive a su eliminación… pero no al cierre de la aplicación;
- El estado almacenado en el dispositivo sobrevive al cierre de la aplicación.
6.2.1. El carrito de compras
| // =========================================================================
// src/app/ex20-shared-state/stores/cart.ts - un ESTADO COMPARTIDO: un servicio
// -------------------------------------------------------------------------
// Un "store" es un estado que vive FUERA de las páginas y de los
// componentes, en UNA SOLA instancia, compartida por todos los que lo leen.
// En Angular, es un SERVICIO (véase el ejemplo 14) cuyo estado está formado por
// SEÑALES. Organización habitual:
// - el ESTADO: señales PRIVADAS (_items);
// - su lectura: vistas de solo lectura (asReadonly);
// - las ACCIONES: métodos, los únicos que modifican el estado;
// - los valores calculados: señales computed.
// Un componente lo obtiene con inject(Cart); su plantilla, que lee las
// señales, se actualiza cuando ESTAS cambian, y solo ellas.
// providedIn: 'root': el servicio se crea en la primera solicitud y vive
// mientras viva la aplicación: sobrevive a la eliminación de un componente... pero
// no a la detención de la aplicación.
// =========================================================================
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[]>([]);
// una vista NO MODIFICABLE del estado: solo las acciones lo cambian
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 {
// un arreglo NUEVO: la señal ve que su valor ha cambiado
this._items.update((items) => [...items, item]);
}
clear(): void {
this._items.set([]);
}
}
|
Un store es un estado que abarca páginas y componentes, y existe como una única instancia compartida por todos los que acceden a él. Con [Angular], es simplemente un servicio (véase el Ejemplo 14) cuyo estado consiste en signals: no hay que agregar ninguna biblioteca, mientras que [Flutter] usaba el paquete [provider] en torno a un [ChangeNotifier].
- línea 26: [providedIn: 'root']: el servicio se crea en su primera solicitud ([inject(Cart)]), como una única instancia, y permanece activo mientras la aplicación esté en ejecución;
- línea 28: el estado: una signal privada;
- Línea 30: una vista de solo lectura del estado ([asReadonly()]): solo las acciones lo modifican;
- Líneas 31–32: valores calculados: signals [computed], recalculadas solo cuando cambia la lista de artículos;
- Líneas 34–41: acciones: métodos, que son los únicos que modifican el estado. Línea 36: un arreglo NUEVO ([...items] copia los artículos), no [push] como en la versión anterior: una signal compara los valores antiguo y nuevo ([===]) y notifica a sus suscriptores solo si difieren. No es necesario escribir [notifyListeners()]: la signal se encarga de la notificación.
6.2.2. Preferencias
| // =========================================================================
// src/app/ex20-shared-state/stores/preferences.ts - un estado que sobrevive a la detención
// -------------------------------------------------------------------------
// Para que un dato sobreviva a la detención de la aplicación, debe almacenarse
// EN EL DISPOSITIVO. El "plugin" @capacitor/preferences ofrece un pequeño
// diccionario clave -> valor (cadenas), propio de la aplicación y
// conservado en el dispositivo (Android: las SharedPreferences; en un
// navegador: el localStorage). Todos sus métodos son ASÍNCRONOS
// (devuelven una Promise):
// - al iniciar, se leen los valores almacenados;
// - en cada cambio, se vuelven a escribir.
// NUNCA se almacenan allí datos sensibles (contraseña, token): se
// escriben en texto plano.
// =========================================================================
import { effect, Injectable, signal } from '@angular/core';
// "as DeviceStorage": renombrado, para no confundirlo con nuestra clase
import { Preferences as DeviceStorage } from '@capacitor/preferences';
const darkKey = 'example20.dark';
const sizeKey = 'example20.size';
@Injectable({ providedIn: 'root' })
export class Preferences {
// el estado inicial: los valores por defecto, a la espera de la lectura
private readonly _dark = signal(false);
private readonly _size = signal(16); // tamaño del texto
readonly dark = this._dark.asReadonly();
readonly size = this._size.asReadonly();
constructor() {
this.load();
// un EFECTO: una función que se vuelve a ejecutar cada vez que cambia una señal que
// lee. Aplica las preferencias a TODA la aplicación:
// - la clase ion-palette-dark en <html>: el tema oscuro de Ionic
// (véase styles.scss);
// - el tamaño de fuente de <html>: los componentes de Ionic tienen
// tamaños en rem (múltiplos de este tamaño), por lo que lo siguen
effect(() => {
document.documentElement.classList.toggle('ion-palette-dark', this._dark());
document.documentElement.style.fontSize = `${this._size()}px`;
});
}
// lo que el dispositivo ha almacenado (value es null si la clave no existe)
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));
}
// un parámetro opcional por preferencia: solo se cambia lo que se proporciona
update({ dark, size }: { dark?: boolean; size?: number }): void {
if (dark !== undefined) {
this._dark.set(dark);
DeviceStorage.set({ key: darkKey, value: String(dark) }); // escritura en el dispositivo
}
if (size !== undefined) {
this._size.set(size);
DeviceStorage.set({ key: sizeKey, value: String(size) });
}
}
}
|
Para que los datos sobrevivan después de cerrar la aplicación, deben almacenarse en el dispositivo. El “plugin” [@capacitor/preferences] de [Capacitor] ofrece un pequeño diccionario de clave a valor (de cadenas), específico de la aplicación y almacenado en el dispositivo: las [SharedPreferences] de [Android] (las que usa el paquete [shared_preferences] de [Flutter]) y, en un navegador, [localStorage]. Todos sus métodos son asíncronos: devuelven una [Promise].
- línea 18: el plugin también se llama [Preferences]; [as DeviceStorage] lo renombra en este archivo para evitar confusiones con nuestra clase;
- Líneas 26–29: el estado inicial, con signals establecidas en sus valores predeterminados, y sus vistas de solo lectura;
- línea 32: la lectura del dispositivo comienza cuando se crea el servicio. Es asíncrona: durante un breve momento se aplican los valores predeterminados;
- líneas 39–42: un efecto ([effect]): una función que se vuelve a ejecutar cada vez que cambia una signal que lee. Aplica las preferencias a TODA la aplicación: la clase CSS [ion-palette-dark] en la etiqueta [<html>] activa el tema oscuro en [Ionic] (definido en [styles.scss]); el tamaño de fuente en [<html>] agranda el texto, porque los componentes de [Ionic] expresan sus tamaños en [rem] (como múltiplos de ese tamaño). Un efecto sirve para esto: retransmitir signals al mundo exterior (DOM, almacenamiento, etc.); no debe usarse para calcular otras signals ([computed] está diseñado para eso);
- líneas 46–51: operación de lectura del dispositivo: [DeviceStorage.get] devuelve una [Promise] de [{ value }], donde [value] es igual a [null] si la clave no existe. Los valores son cadenas: se convierten;
- líneas 54–63: una única acción con parámetros opcionales (un objeto desestructurado: [{ dark, size }]): solo se cambia el valor proporcionado, y se escribe de inmediato en el dispositivo ([DeviceStorage.set]). No esperamos a que termine la escritura: la signal ya ha cambiado.
NUNCA almacene datos sensibles (contraseñas, tokens) allí: se escriben en texto plano. Para ello existen plugins que usan la bóveda del sistema ([Keystore] de [Android], [Keychain] de [iOS]).
6.2.3. Los componentes
| // =========================================================================
// src/app/ex20-shared-state/components/shop.ts - AGREGA al carrito compartido
// -------------------------------------------------------------------------
// La tienda solo LLAMA a una acción del carrito; su plantilla no lee
// ninguna señal del carrito: no se actualiza cuando el carrito cambia.
// =========================================================================
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;
// el MISMO carrito que el de los demás componentes (una sola instancia)
readonly cart = inject(Cart);
constructor() {
addIcons({ add });
}
}
|
| <!-- ======================================================================
shop.html - dos productos para agregar al carrito
====================================================================== -->
<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>
|
- línea 28 (.ts): [inject(Cart)] devuelve el MISMO carrito de compras que los demás componentes;
- línea 11 (html): la tienda simplemente llama a una acción. Su plantilla no lee ninguna signal del carrito de compras: no se actualiza cuando este cambia (esto era [context.read<Cart>()] con [provider]);
- línea 13 (html): el pipe [currency] formatea el precio al estilo inglés (véase el ejemplo 09).
| // =========================================================================
// src/app/ex20-shared-state/components/cart-summary.ts - LEE el mismo carrito
// -------------------------------------------------------------------------
// La plantilla lee dos señales del carrito, count() y total(): se actualiza
// cuando UNA de ellas cambia, y solo entonces.
// =========================================================================
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 - el número de artículos y el total del carrito
====================================================================== -->
<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>
|
- Líneas 8–9 (HTML): la plantilla lee dos signals del carrito de compras, [count()] y [total()]: se actualiza cuando cualquiera de ellas cambia, y solo entonces. Con [provider], había que elegir entre [context.watch] (todo el carrito de compras) y [context.select] (un solo artículo); con las signals, la precisión es automática: depende de lo que se lee.
| // =========================================================================
// src/app/ex20-shared-state/components/local-counter.ts - un estado LOCAL
// -------------------------------------------------------------------------
// La señal clicks pertenece al componente: nace con él y desaparece
// con él.
// =========================================================================
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 - un contador de clics
====================================================================== -->
<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>
|
Un estado local (línea 18 del archivo .ts), que se crea y se destruye junto con el componente.
6.2.4. La página
| // =========================================================================
// src/app/ex20-shared-state/ex20.page.ts - tres "ámbitos" de datos
// -------------------------------------------------------------------------
// - el estado LOCAL de un componente (LocalCounter) desaparece con él;
// - el estado de un SERVICIO (el carrito) es compartido por todos los componentes
// y sobrevive a su eliminación, pero no a la detención de la aplicación;
// - el estado almacenado en el dispositivo (las preferencias) sobrevive a la detención.
// Y la clase CSS ion-hide: el contenido se OCULTA, pero no se elimina; su
// estado local se conserva.
// Desmarque y vuelva a marcar "mostrar el área", luego detenga y reinicie
// la aplicación: compare.
// =========================================================================
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);
// un estado local de la página
readonly areaVisible = signal(true);
}
|
| <!-- ======================================================================
ex20.page.html - un estado compartido
====================================================================== -->
<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]: el valor del servicio; (ionChange): la acción que lo modifica -->
<ion-toggle [checked]="preferences.dark()"
(ionChange)="preferences.update({ dark: $event.detail.checked })">dark theme</ion-toggle>
</ion-item>
<ion-item>
<!-- snaps / ticks: marcas, en cada paso -->
<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>
<!-- eliminados: estos componentes desaparecen, con su estado local -->
@if (areaVisible()) {
<app-ex20-shop />
<app-ex20-cart-summary />
<app-ex20-local-counter title="Local state" />
}
<!-- oculto (ion-hide: display none): el componente permanece en memoria, su estado se conserva -->
<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>
|
- línea 33 (.ts): las preferencias, un servicio; se crea (y lee el dispositivo) en su primera solicitud;
- línea 35 (.ts): un estado local de la página: ¿se muestra el área?
- líneas 18–19 (html): un interruptor ([<ion-toggle>]): [[checked]] recibe el valor del servicio y [(ionChange)] llama a su acción;
- líneas 23–26 (html): un control deslizante ([<ion-range>]) que va de 12 a 22, con marcas ([snaps], [ticks]); [+$event.detail.value] convierte el valor en número;
- líneas 29–30 (html): una casilla de verificación, enlazada al estado local;
- líneas 35–39 (HTML): eliminada ([@if]); el área desaparece: sus componentes se DESTRUYEN, junto con su estado local;
- línea 41 (html): oculta mediante la clase CSS [ion-hide] de [Ionic] ([display: none]); el componente permanece en memoria: su estado se conserva. [[class.ion-hide]="..."] establece la clase cuando la expresión es verdadera. (Antes esto era [Visibility(maintainState: true)] de [Flutter].)
- Línea 44 (html): un segundo resumen del mismo carrito de compras, fuera del área.
El carrito de compras y las preferencias se comparten en toda la aplicación ([providedIn: 'root']). Para que un servicio sea específico de una página (una instancia por página, destruida junto con ella), se declara en los [providers] de su componente, como se muestra en el Ejemplo 21.
6.2.5. Ejecución
Agregamos dos artículos, hacemos clic dos veces en el primer contador local y una vez en el segundo (a la izquierda); eliminamos el área y cambiamos al tema oscuro (en el centro); restauramos el área (a la derecha):
El carrito de compras sobrevivió a la eliminación de la sección (como se ve en el segundo resumen); el contador eliminado volvió a cero; el contador oculto conservó su valor. Detenga la aplicación y vuelva a iniciarla (en el navegador: recargue la página): el tema oscuro y el tamaño del texto se conservan, y el carrito de compras está vacío. Las preferencias se aplican a toda la aplicación: al volver al menú, este también está en modo oscuro.
¿Por qué no usar una biblioteca de gestión de estado? Existen varias para [Angular] ([NgRx], su variante [SignalStore], [NGXS]...), al igual que para [Flutter] ([provider], [Riverpod], [Bloc]...). Pero la inyección de dependencias y las signals ya cubren lo esencial: un servicio basado en signals es un store, y eso es lo que usará el caso de estudio.