Skip to content

5. Estado asíncrono y compartido

5.1. Ejemplo 19: procesamiento asíncrono

Muchas cosas ocurren “más tarde”: tics de un temporizador, pulsaciones de teclas, respuestas del servidor. [Angular] se apoya para ello en la biblioteca [RxJS] y sus observables. [React] no tiene herramientas asíncronas propias: se combinan estado, efectos y su limpieza, que se guardan en hooks; y, a partir de [React] 19, [use()] y [<Suspense>] permiten esperar una promesa.

5.1.1. Una cuenta regresiva

// =========================================================================
// 19-asynchronous/src/hooks/useCountdown.ts - un temporizador en un hook
// -------------------------------------------------------------------------
// Desde el inicio hasta 0, un valor por segundo. El temporizador se detiene cuando la
// cuenta llega a 0... o cuando el componente desaparece (limpieza).
// =========================================================================

import { useEffect, useState } from 'react';

export function useCountdown(start: number): number {
  const [remaining, setRemaining] = useState(start);

  // [remaining > 0]: el efecto se reinicia cuando cambia esta condición, es decir
  // una sola vez, cuando la cuenta llega a 0 (el temporizador se detiene entonces)
  const active = remaining > 0;
  useEffect(() => {
    if (!active) return;
    const timer = setInterval(() => setRemaining((r) => r - 1), 1000);
    return () => clearInterval(timer);
  }, [active]);

  return remaining;
}
  • línea 11: el contador;
  • línea 15: el contador;
  • líneas 16–20: el efecto depende únicamente de [active]: se ejecuta al inicio (arranca el temporizador) y luego solo una vez más, cuando la cuenta llega a 0; su limpieza detiene entonces el temporizador, y la nueva ejecución no hace nada. [setRemaining((r) => r - 1)] usa la forma de “función” de la actualización: el temporizador se creó una sola vez y para siempre y no ve los nuevos valores de [remaining]; la función, en cambio, recibe el valor actual.

5.1.2. Antirrebote

// =========================================================================
// 19-asynchronous/src/hooks/useDebouncedValue.ts - "debounce"
// -------------------------------------------------------------------------
// Devuelve el valor recibido... pero solo cuando no ha cambiado más
// durante delay milisegundos. Para una búsqueda mientras se escribe:
// se espera a que el usuario haga una pausa antes de consultar al servidor,
// en lugar de enviar una solicitud por cada tecla.
// El principio: cada nuevo valor reinicia el efecto, cuya limpieza
// cancela el temporizador del valor anterior.
// =========================================================================

import { useEffect, useState } from 'react';

export function useDebouncedValue<T>(value: T, delay: number): T {
  const [debounced, setDebounced] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => setDebounced(value), delay);
    return () => clearTimeout(timer); // una pulsación de tecla antes del final: cancelar
  }, [value, delay]);

  return debounced;
}

Para una funcionalidad de “búsqueda mientras se escribe”, se espera a que el usuario haga una pausa antes de consultar al servidor, en lugar de enviar una solicitud con cada pulsación de tecla: esto es el antirrebote ([debounce]). El hook devuelve el valor recibido... pero solo cuando no ha cambiado durante [delay] milisegundos:

  • líneas 17–20: cada nuevo valor reinicia el efecto, que establece un temporizador; y la limpieza de la ejecución anterior CANCELA el temporizador del valor anterior. Por lo tanto, solo el último valor, seguido de una pausa, llega a [setDebounced].

El hook es genérico ([<T>]): funciona con valores de cualquier tipo.

5.1.3. La página

// =========================================================================
// 19-asynchronous/src/App.tsx - temporizadores, búsqueda mientras se escribe, use()
// -------------------------------------------------------------------------
// Muchas cosas ocurren "más tarde": los tics de un temporizador, las
// pulsaciones de teclas, la respuesta de un servidor. React no tiene herramienta propia
// para la asincronía (Angular usa la biblioteca RxJS): combinamos
// el estado, los efectos y su limpieza, almacenados en hooks (hooks/),
// y, desde React 19, use() + <Suspense> para esperar una promesa.
// =========================================================================

import { Suspense, use, useEffect, useState } from 'react';
import { useCountdown } from './hooks/useCountdown';
import { useDebouncedValue } from './hooks/useDebouncedValue';

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

// un "servidor" simulado: la respuesta llega tras un retraso aleatorio
function search(text: string): Promise<string[]> {
  const found = DOCTORS.filter((m) => m.toLowerCase().includes(text));
  return new Promise((resolve) => setTimeout(() => resolve(found), 200 + Math.random() * 600));
}

// 3. una promesa, creada UNA vez (fuera del componente): se resuelve después de
// un segundo
const messagePromise = new Promise<string>((resolve) =>
  setTimeout(() => resolve('three (one second later)'), 1000),
);

// use(promise): el valor de la promesa. Mientras no esté
// resuelta, el componente "suspende" su visualización: el <Suspense> más cercano
// muestra en su lugar su contenido de espera (fallback)
function Message({ promise }: { promise: Promise<string> }) {
  const value = use(promise);
  return <p className="mb-0">received: {value}</p>;
}

export default function App() {
  const [log, setLog] = useState<string[]>([]);
  const trace = (message: string) => setLog((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);

  // 1. una cuenta regresiva: un hook casero
  const countdown = useCountdown(20);

  // 2. una búsqueda mientras se escribe
  const [input, setInput] = useState('');
  const text = useDebouncedValue(input.trim().toLowerCase(), 400); // después de 400 ms sin pulsar una tecla
  const [results, setResults] = useState<string[]>([]);

  useEffect(() => {
    if (text.length < 2) {
      return; // sin búsqueda (y sin limpieza)
    }
    // "obsoleta" (stale): una respuesta que llega DESPUÉS de que se haya iniciado otra búsqueda
    // debe ignorarse (de lo contrario, una respuesta lenta de una búsqueda
    // antigua sobrescribiría la de la nueva)
    let stale = false;
    trace(`search sent: "${text}"`);
    search(text).then((found) => {
      if (stale) {
        trace(`response ignored (stale): "${text}"`);
        return;
      }
      setResults(found);
    });
    // la limpieza: se ejecuta cuando cambia text (nueva búsqueda) o al eliminar el componente
    return () => {
      stale = true;
    };
  }, [text]);

  // menos de dos letras: ningún resultado, sean cuales sean los de la
  // última búsqueda (un valor calculado, no un estado más)
  const displayed = text.length < 2 ? [] : results;

  return (
    <div className="container py-4" style={{ maxWidth: 720 }}>
      <h1 className="h3 mb-3">Example 19 - asynchrony</h1>

      <div className="card p-3 mb-3">
        <h2 className="h6">A countdown (setInterval in a hook)</h2>
        <p className="display-6 mb-0">{countdown}</p>
      </div>

      <div className="card p-3 mb-3">
        <h2 className="h6">A search as you type (debounce, stale responses)</h2>
        <input className="form-control mb-2" placeholder="at least two letters: pel, dur..." value={input}
               onChange={(e) => setInput(e.target.value)} />
        <ul className="mb-0">
          {displayed.map((r) => <li key={r}>{r}</li>)}
          {displayed.length === 0 && <li className="text-muted">no result</li>}
        </ul>
      </div>

      <div className="card p-3 mb-3">
        <h2 className="h6">Waiting for a promise (use and Suspense)</h2>
        <Suspense fallback={<p className="text-muted mb-0">waiting...</p>}>
          <Message promise={messagePromise} />
        </Suspense>
      </div>

      <h2 className="h6">Log</h2>
      <ol className="small">
        {log.map((line, i) => <li key={i}>{line}</li>)}
      </ol>
    </div>
  );
}
  • líneas 18–21: un “servidor” simulado: la respuesta llega tras un retraso aleatorio de 200 a 800 ms;
  • líneas 25–27: una promesa, creada UNA SOLA VEZ (fuera del componente), resuelta después de un segundo;
  • líneas 32–35: [use(promise)] devuelve el valor de una promesa. Mientras no esté resuelta, el componente “suspende” su visualización: el [<Suspense>] más cercano (línea 96) muestra su contenido provisional ([fallback]). Cuando la promesa se resuelve, [React] vuelve a llamar al componente, y [use] devuelve el valor. La promesa debe crearse FUERA del componente o mediante una biblioteca que la almacene en caché: una promesa creada durante el renderizado se volvería a crear con cada llamada, y la espera nunca terminaría;
  • línea 42: el hook personalizado;
  • línea 46: el texto de búsqueda, tras 400 ms sin pulsaciones de teclas;
  • líneas 49–69: la búsqueda, que se reinicia cuando cambia el texto (en caché):
    • el problema de las respuestas obsoletas: se escribe “pel”, se hace una pausa y comienza la búsqueda; se escribe “du”, se hace una pausa y comienza una segunda búsqueda. Si la respuesta a “pel” llega DESPUÉS de la de “du” (los retrasos de red son impredecibles), sobrescribiría los resultados correctos;
    • La solución (líneas 56–67): una variable propia de CADA ejecución del efecto, que se restablece a [true] cuando el texto cambia. Toda respuesta que llegue después se ignora;
  • línea 73: menos de dos letras: sin resultados, sin importar los resultados de la última búsqueda. Es un valor calculado, no un estado adicional.

Se escribe “pel”, se espera un momento y luego se escribe “du”; la respuesta a “pel” llega demasiado tarde y se ignora:

Image

Escribir uno mismo el código de manejo de consultas (en curso, exitosa, con error, vencida, ya en caché, etc.) es tedioso. Para comunicarse con un servidor, en la práctica se usa una biblioteca que se encarga de ello: en el ejemplo 24, será [TanStack Query].

5.2. Ejemplo 20: un estado compartido

El ejemplo 18 muestra cómo escribir un store a mano. La biblioteca [Zustand] hace lo mismo en unas pocas líneas, y es una de las bibliotecas más utilizadas para gestionar el estado compartido en una aplicación [React] (junto con [Redux Toolkit], que es más completa pero también más pesada en recursos).

5.2.1. El carrito de compras

// =========================================================================
// 20-shared-state/src/stores/cart.ts - un ESTADO COMPARTIDO, con Zustand
// -------------------------------------------------------------------------
// Un "store" es un estado que vive FUERA de los componentes, en UNA sola
// copia, compartida por todos los que lo leen. El ejemplo 18 escribió
// uno a mano (useSyncExternalStore); la biblioteca Zustand hace lo
// mismo en pocas líneas:
//
//     const useCart = create<Cart>()((set, get) => ({ ...estado y acciones... }));
//
// create devuelve un HOOK. Un componente lee de él lo que necesita, mediante un
// "selector": useCart((p) => p.items). Solo se vuelve a llamar si ESTA
// parte del estado cambia. Organización habitual:
//   - el ESTADO: datos (items);
//   - las ACCIONES: funciones, las únicas que modifican el estado, mediante set();
//   - los valores calculados: funciones (o selectores).
// El store vive mientras vive la aplicación: sobrevive a la eliminación de un
// componente... pero no a la recarga de la página (F5), que reinicia
// la aplicación. (Context + useReducer puede hacer el mismo trabajo;
// un store tiene la ventaja de poder leerse también FUERA de los componentes.)
// =========================================================================

import { create } from 'zustand';

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

interface Cart {
  items: Item[];
  add: (item: Item) => void;
  clear: () => void;
}

export const useCart = create<Cart>()((set) => ({
  items: [],
  // set(función): recibe el estado actual, devuelve lo que cambia (el resto se conserva)
  add: (item) => set((p) => ({ items: [...p.items, item] })),
  clear: () => set({ items: [] }),
}));

// selectores reutilizables: valores calculados a partir del estado
export const itemCount = (p: Cart) => p.items.length;
export const cartTotal = (p: Cart) => p.items.reduce((s, a) => s + a.price, 0);
  • línea 23: la función que crea un store;
  • líneas 30–34: el tipo del store: el estado ([items]) y las acciones ([add], [clear]), que son las únicas que pueden modificarlo;
  • líneas 36–41: [create<Cart>()(factory)] crea el store y devuelve un hook. La fábrica recibe [set], que modifica el estado: [set(object)] o [set((state) => object)]; solo se pasan los cambios; el resto se conserva. Como con [useState], el estado en sí nunca se modifica: se crea uno nuevo;
  • Líneas 44–45: selectores: funciones que calculan un valor a partir del estado.

El store existe mientras la aplicación esté en ejecución, en UNA SOLA copia: sobrevive a la eliminación de un componente... pero no a una recarga de la página (F5), que reinicia la aplicación. El contexto y [useReducer] podrían hacer el mismo trabajo; un store tiene dos ventajas: también se puede leer fuera de los componentes (por un guardia del enrutador, por ejemplo), y un componente solo se vuelve a llamar si cambia la parte del estado que lee.

5.2.2. Preferencias

// =========================================================================
// 20-shared-state/src/stores/preferences.ts - un estado que sobrevive a F5
// -------------------------------------------------------------------------
// Para que un dato sobreviva a la recarga de la página, o al cierre
// del navegador, debe almacenarse EN el navegador: localStorage (un
// pequeño diccionario clave -> cadena, específico de cada sitio).
// El "middleware" persist de Zustand se encarga de ello: relee localStorage en
// la creación del store y lo reescribe en cada cambio (clave
// "example20.preferences", valor: el JSON del estado).
// NUNCA almacene datos sensibles en él (contraseña, token): cualquier script
// de la página puede leer localStorage.
// =========================================================================

import { create } from 'zustand';
import { persist } from 'zustand/middleware';

interface Preferences {
  dark: boolean;
  size: number; // tamaño del texto, en px
  update: (change: Partial<Pick<Preferences, 'dark' | 'size'>>) => void;
}

export const usePreferences = create<Preferences>()(
  persist(
    (set) => ({
      dark: false,
      size: 16,
      update: (change) => set(change),
    }),
    { name: 'example20.preferences' },
  ),
);

Para que los datos persistan después de recargar la página o cerrar el navegador, deben almacenarse EN el navegador: [localStorage], un pequeño diccionario de clave/cadena propio de cada sitio. El “middleware” [persist] de [Zustand] se encarga de esto (líneas 24–31): lee [localStorage] al crear el store y lo reescribe cada vez que ocurre un cambio, bajo la clave [example20.preferences] (línea 30). Los datos sensibles (contraseñas, tokens) NUNCA se almacenan allí: cualquier script de la página puede leer [localStorage].

5.2.3. Los componentes

// 20-shared-state/src/components/Shop.tsx - AGREGA al carrito compartido
import { useCart, type Item } from '../stores/cart';

const PRODUCTS: Item[] = [
  { label: 'Consultation', price: 30 },
  { label: 'Vaccine', price: 12.5 },
];

export default function Shop() {
  // solo se lee la acción: Shop no se vuelve a llamar cuando cambia el carrito
  const add = useCart((p) => p.add);
  return (
    <div className="card p-3 h-100">
      <h2 className="h6">Shop</h2>
      {PRODUCTS.map((p) => (
        <button key={p.label} className="btn btn-sm btn-outline-primary mb-2" onClick={() => add(p)}>
          + {p.label} (€{p.price})
        </button>
      ))}
    </div>
  );
}

[useCart((p) => p.add)]: un componente lee el store mediante un selector y solo se llama si cambia LA parte del estado que lee. [Shop] solo lee la acción [add], que nunca cambia: nunca se llama cuando cambia el carrito de compras.

// 20-shared-state/src/components/CartSummary.tsx - LEE el mismo carrito
import { itemCount, cartTotal, useCart } from '../stores/cart';

export default function CartSummary() {
  const count = useCart(itemCount);
  const total = useCart(cartTotal);
  const clear = useCart((p) => p.clear);
  return (
    <div className="card p-3 h-100">
      <h2 className="h6">Cart</h2>
      <p className="mb-2">{count} item(s), €{total}</p>
      <button className="btn btn-sm btn-outline-danger align-self-start" disabled={count === 0} onClick={clear}>Clear</button>
    </div>
  );
}

[CartSummary] lee la cantidad de artículos y el total mediante los selectores del store.

// 20-shared-state/src/components/LocalCounter.tsx - un estado LOCAL, que desaparece con el componente
import { useState } from 'react';

export default function LocalCounter({ title }: { title: string }) {
  const [clicks, setClicks] = useState(0);
  return (
    <div className="card p-3 h-100">
      <h2 className="h6">{title}</h2>
      <button className="btn btn-sm btn-outline-secondary align-self-start" onClick={() => setClicks(clicks + 1)}>
        {clicks} click(s)
      </button>
    </div>
  );
}

Un estado LOCAL, que desaparece junto con el componente.

5.2.4. La página

// =========================================================================
// 20-shared-state/src/App.tsx - tres "ámbitos" de datos en el lado del cliente
// -------------------------------------------------------------------------
// La misma pregunta que el ejemplo 23 del curso de NestJS (ámbito de aplicación, de solicitud,
// de cliente), trasladada al navegador:
//   - el estado LOCAL de un componente (LocalCounter) desaparece con él;
//   - el estado de un STORE (el carrito) es compartido por todos los componentes
//     y sobrevive a su eliminación, pero no a F5;
//   - el estado almacenado en localStorage (las preferencias) sobrevive a F5 y al
//     cierre del navegador.
// Y una novedad de React 19.2, <Activity mode="hidden">: el contenido se
// OCULTA, pero no se elimina; su estado local se conserva.
// Desmarque y vuelva a marcar "mostrar el área", luego recargue la página: compare.
// =========================================================================

import { Activity, useState } from 'react';
import { usePreferences } from './stores/preferences';
import Shop from './components/Shop';
import CartSummary from './components/CartSummary';
import LocalCounter from './components/LocalCounter';

export default function App() {
  const { dark, size, update } = usePreferences();
  const [areaVisible, setAreaVisible] = useState(true);

  return (
    <div className={`min-vh-100 ${dark ? 'bg-dark text-light' : ''}`} style={{ fontSize: size }}>
      <div className="container py-4">
        <h1 className="h3 mb-3">Example 20 - a shared state</h1>
        <div className="d-flex flex-wrap gap-4 mb-3">
          <label className="form-check-label">
            <input type="checkbox" className="form-check-input" checked={dark}
                   onChange={(e) => update({ dark: e.target.checked })} /> dark theme
          </label>
          <label>
            text size{' '}
            <input type="range" min={12} max={22} value={size}
                   onChange={(e) => update({ size: e.target.valueAsNumber })} /> {size} px
          </label>
          <label className="form-check-label">
            <input type="checkbox" className="form-check-input" checked={areaVisible}
                   onChange={(e) => setAreaVisible(e.target.checked)} /> show the area
          </label>
        </div>
        <div className="row g-3 text-body">
          {/* eliminados: estos componentes desaparecen, con su estado local */}
          {areaVisible && (
            <>
              <div className="col-md-3"><Shop /></div>
              <div className="col-md-3"><CartSummary /></div>
              <div className="col-md-3"><LocalCounter title="Local state" /></div>
            </>
          )}
          {/* oculto: el componente permanece en memoria, su estado se conserva */}
          <Activity mode={areaVisible ? 'visible' : 'hidden'}>
            <div className="col-md-3"><LocalCounter title="Local state, in an Activity" /></div>
          </Activity>
        </div>
        <p className="mt-3 mb-2">Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
        <div className="text-body"><CartSummary /></div>
      </div>
    </div>
  );
}
  • línea 23: sin un selector, se lee el store completo (y el componente se vuelve a llamar con cada cambio);
  • líneas 47–53: el campo se elimina cuando se desmarca la casilla: sus componentes desaparecen, junto con su estado local;
  • líneas 55–57: [<Activity mode="hidden">] ([React] 19.2) oculta su contenido sin eliminarlo: el componente permanece en memoria, junto con su estado. Esto es útil para pestañas o para una página que se abandona y a la que se vuelve.
  • línea 60: fuera del área, un segundo resumen del MISMO carrito de compras.

Agregue dos artículos al carrito de compras, haga doble clic en el primer contador local y triple clic en el de el [Activity], desmarque y vuelva a marcar “show the area” y marque “dark theme”:

Image

El carrito de compras permanece intacto (está en el store); el primer contador se reinició a 0 (su componente se eliminó y luego se volvió a crear); el de [Activity] ha conservado su valor. Al recargar la página (F5), el carrito de compras está vacío, pero se conservan el tema y el tamaño del texto ([localStorage]).

Es el mismo problema que el ejemplo 23 del curso de [NestJS] (ámbito de aplicación, consulta, cliente), trasladado al navegador.