Saltar al contenido
Asincronía

Cancelar con AbortController

Lección 8 de 910 min4 ejercicios

El usuario escribe en un buscador, y cada letra lanza una búsqueda. Si escribe rápido, las respuestas viejas ya no sirven: hay que cancelarlas. Una promesa, por sí sola, no se puede detener. Para eso existe AbortController, el mecanismo estándar de cancelación de la web y de Node.js.

Controlador y señal

Hay dos piezas:

  • El controlador (AbortController) es el botón de cancelar: tiene el método abort().
  • La señal (controller.signal) es lo que se le pasa a la operación. Avisa cuando se cancela.
const control = new AbortController();
const { signal } = control;

signal.addEventListener("abort", () => {
  console.log("se canceló:", signal.reason);
});

console.log(signal.aborted);  // false
control.abort("ya no hace falta");
console.log(signal.aborted);  // true

Quien cancela no necesita saber nada de la operación; la operación no necesita saber quién cancela. Solo comparten la señal.

Cancelar un fetch

fetch acepta una señal. Si se cancela, la promesa se rechaza con un error de nombre AbortError:

const control = new AbortController();

fetch("/api/buscar?q=java", { signal: control.signal })
  .then((r) => r.json())
  .then((datos) => mostrar(datos))
  .catch((e) => {
    if (e.name === "AbortError") return;  // cancelada a propósito: no es un error
    mostrarError(e);
  });

// El usuario siguió escribiendo: esta búsqueda ya no sirve
control.abort();

Distinguir AbortError del resto es importante: una cancelación intencional no debería mostrarse como un fallo.

Límites de tiempo y señales combinadas

AbortSignal.timeout(ms) crea una señal que se cancela sola. AbortSignal.any([…]) combina varias: se cancela en cuanto lo hace cualquiera.

const usuario = new AbortController();

const señal = AbortSignal.any([
  usuario.signal,            // el botón «cancelar»
  AbortSignal.timeout(100),  // o 100 ms, lo que pase primero
]);

señal.addEventListener("abort", () => {
  console.log("cancelada por:", señal.reason.name);
});

Si la señal se canceló por tiempo, el motivo es un error de nombre TimeoutError; si fue por abort() sin argumento, AbortError.

Tus propias funciones cancelables

Cualquier función asíncrona puede respetar una señal. El contrato es siempre el mismo:

  1. Si la señal ya está cancelada, rechazar enseguida.
  2. Escuchar el evento abort.
  3. Al cancelarse, liberar lo que se estaba usando (temporizadores, conexiones) y rechazar con signal.reason.
function esperar(ms, signal) {
  return new Promise((ok, mal) => {
    if (signal?.aborted) return mal(signal.reason);
    const id = setTimeout(ok, ms);
    signal?.addEventListener("abort", () => {
      clearTimeout(id);
      mal(signal.reason);
    }, { once: true });
  });
}

try {
  await esperar(1000, AbortSignal.timeout(50));
} catch (e) {
  console.log("detenida:", e.name);
}

Resumen

  • AbortController cancela; su signal se le pasa a la operación.
  • fetch(url, { signal }) se rechaza con AbortError al cancelarse: no lo trates como un fallo.
  • AbortSignal.timeout(ms) cancela por tiempo (TimeoutError); AbortSignal.any combina señales.
  • Una función cancelable comprueba signal.aborted, escucha abort, libera recursos y rechaza con signal.reason.
  • Un controlador por operación: una señal cancelada lo está para siempre.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Detener lo que ya empezó

Elige una respuesta en cada pregunta.

  1. ¿Cómo se usa un AbortController?

  2. ¿Qué hace AbortSignal.timeout(3000)?

  3. ¿Para qué sirve AbortSignal.any([s1, s2])?

  4. ¿Se puede reutilizar un controlador después de llamar a abort()?

Ordena la salida: Señales y motivos

Una señal que se cancela dos veces. Ordena lo que aparecería en la consola.

const control = new AbortController();const { signal } = control; signal.addEventListener("abort", () => console.log("aviso:", signal.reason)); console.log("¿cancelada?", signal.aborted);control.abort("el usuario cerró la ventana");console.log("¿cancelada?", signal.aborted);control.abort("otra vez");console.log("motivo:", signal.reason);

Consola, de arriba abajo

  1. ¿cancelada? true
  2. ¿cancelada? false
  3. motivo: el usuario cerró la ventana
  4. aviso: el usuario cerró la ventana

Detective: Un controlador reutilizado

Una búsqueda nueva se cancela antes de empezar. Encuentra la línea y elige el arreglo.

Consola

nueva búsqueda…
busqueda.js:3
    if (signal.aborted) return mal(signal.reason);
                               ^

AbortError: This operation was aborted

Paso 1: toca la línea de código que causa el error.

Laboratorio: Una espera cancelable

Escribe esperar(ms, signal): una espera que se puede cancelar.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime cancelado, a los 30 ms y no a los 500 (pendiente)
  • Sin cancelación, se cumple a tiempo (pendiente)
  • Con una señal ya cancelada, rechaza enseguida (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.