AbortController: cancela operaciones en JavaScript
15-07-2022
Hasta ahora, en JavaScript, cuando se lanzaba una llamada a una API con fetch, no resultaba sencillo detenerla. También se podía dar el caso de que quisiéramos detener varias operaciones que se ejecutaban de simultáneamente de forma centralizada, por lo que teníamos que implementar sistemas como el patrón observador.
Pero en la actualidad, estos flujos ahora son más fáciles gracias a la clase AbortController que viene a proporcionarnos una forma de enviar una señal de parada a todo elemento que lo utilice. Básicamente, tendremos una señal (AbortSignal) que se emitirá cuando queramos cancelar una operación.
Veamos el uso más básico, y que está en miles de ejemplos:
const abortController = new AbortController();
const abortSignal = abortController.signal;
fetch("http://urldelaapi/to/api/call", { signal: abortSignal })
.then(function(response) {
console.log("Respuesta obtenida", response);
})
.catch(function(e) {
console.log("Algo ha fallado o lo han cancelado: " + e.message);
});
// Tras alguna interacción del usuario por ejemplo, cancelamos la operación.
abortController.abort();
En el código anterior podemos ver como el uso de AbortController se reduce a obtener su señal, con signal, y a llamar al método abort() para lanzar la señal.
Aunque es una herramienta muy potente, no hay mucho más que explicar... bueno sí, el 99,9% de los ejemplos que podéis encontrar, son como el que he puesto en las líneas anteriores, pero, ¿y si queréis usar la clase AbortController en algo que no sea un fetch? ¿Cómo se puede escuchar el cambio en la señal? Pues a continuación he preparado un código muy sencillito. En él podéis ver como hay tres contadores avanzando, lo que haremos es detenerlos mediante una señal:
Lo que hemos hecho es definir una clase Timer a la que pasamos la señal de abortar la operación:
// El controler viene de: controller = new AbortController();
const timer1 = new Timer("timer1", controller.signal);
const timer2 = new Timer("timer2", controller.signal);
const timer3 = new Timer("timer3", controller.signal);
En el constructor escuchamos el evento abort para dicha señal asociándolo con un event listener e indicando al código a ejecutar cuando llegue dicha señal. En nuestro caso el método #onAbort():
// No usamos .bind porque #onAbort está declarado como arrow function.
this.#signal.addEventListener("abort", this.#onAbort);
Podemos, además enviar una cadena para indicar la razón por la que hemos enviado la señal. Esta razón se recogerá en el atributo reason del evento.
// Tras declarar el controler, recuerda: controller = new AbortController();
// Se especifica la razón
controller.abort("Stopped by user");
// Con event.currentTarget.reason podemos obtener dicho valor
console.warn(`Stopped ${this.#name} by: ${event.currentTarget.reason}`);
Como punto final, imaginad que tenéis varias llamadas simultáneas a un API porque es necesario solicitar datos en paralelo en vuestra aplicación. Ahora pongámonos en una situación en la que el usuario quiere cancelar la carga de datos en paralelo, por ejemplo, abrió una modal que hace varias llamadas y la cierra inmediatamente. Podemos detener de forma centralizada todas estas llamadas (al igual que hicimos con el ejemplo de los temporizadores):
class AnyModal {
#abortController = null;
async openModal() {
// Si ya había una petición en curso, la cancelamos antes de empezar
// la nueva
if (this.#abortController) {
this.#abortController.abort();
}
this.#abortController = new AbortController();
const abortSignal = this.#abortController.signal;
try {
const [r1, r2, r3] = await Promise.all([
fetch("https://example.com/api/call/1", { signal }),
fetch("https://example.com/api/call/2", { signal }),
fetch("https://example.com/api/call/3", { signal })
]);
// manejar respuestas
} catch (err) {
if (err.name === "AbortError") {
console.log("Carga cancelada por el usuario");
} else {
console.error("Error en llamadas:", err);
}
} finally {
// Liberamos el controller cuando todo ha terminado (exitoso o no)
this.#abortController = null;
}
}
closeModal() {
if (this.#abortController) {
this.#abortController.abort();
this.#abortController = null;
}
}
}
Como habéis podido comprobar, AbortController es una herramienta muy sencilla a la par que potente, y que nos puede dar muchos más usos de los que he comentado aquí. Como siempre, espero que este breve artículo os haya servido de ayuda.
Si estás empezando a programar, o empezando otra vez, en Guía de Programación en un Apocalipsis Zombi enseño TypeScript desde cero con problemas como los de aquí, solo que con zombis en la puerta. Hay un fragmento gratis para que pruebes antes de comprar, y si tienes Kindle Unlimited, el libro entero te sale gratis.