Las promesas en JavaScript ganaron un nuevo aliado con ECMAScript 9: el método finally, que se ejecuta cuando la promesa termina, sin importar si fue resuelta o rechazada. Junto con las iteraciones asíncronas (for await...of) y los generadores con async/await, esta versión amplía el control sobre flujos asincrónicos en aplicaciones modernas.

¿Qué hace finally en una promesa de JavaScript?

El bloque finally se ejecuta siempre al cerrar el ciclo de una promesa, después de then o catch. Sirve para liberar recursos, ocultar loaders o mostrar mensajes de cierre sin duplicar lógica.

Imagina que llamas a una API y quieres apagar un spinner sin importar el resultado. Antes de ECMAScript 9 tenías que repetir esa instrucción en then y en catch. Con finally la escribes una sola vez.

¿Cuándo se ejecuta finally? Después de que la promesa se resuelve o se rechaza. No importa si entraste a then o catch: el bloque siempre corre al final [02:00].

¿Cómo se escribe finally con resolve y reject?

La sintaxis se encadena como cualquier otro método de promesa. Tomas el ejemplo de promesa que ya conoces de ECMAScript 6 y agregas el bloque al final con una arrow function.

js miPromesa .then(response => console.log(response)) .catch(error => console.log(error)) .finally(() => console.log('Por fin terminó'));

Al ejecutar, si la promesa cae en resolve, verás el mensaje del then y luego Por fin terminó. Si entra en reject, pasa por catch y también imprime el finally. Ese cierre es lo interesante: siempre se cumple.

¿Cómo funcionan las iteraciones asíncronas con generators?

ECMAScript 9 sumó el manejo de asynchronous iteration, que combina los generators de ECMAScript 6 con el async/await que llegó en ECMAScript 8. La idea: pausar la entrega de valores hasta que cada promesa interna se resuelva.

Un generator se declara con function* y usa yield para entregar valores por demanda. Cuando lo marcas como async, puedes hacer yield await sobre una promesa.

js async function* anotherGenerator() { yield await Promise.resolve(1); yield await Promise.resolve(2); yield await Promise.resolve(3); }

const another = anotherGenerator(); another.next().then(response => console.log(response.value)); another.next().then(response => console.log(response.value)); another.next().then(response => console.log(response.value));

Al correrlo verás Hello, 1, 2, 3 (si imprimes un saludo antes). El método next() devuelve una promesa con value y done, por eso necesitas then para acceder al valor [05:30].

¿Qué pasa si quitas async del generator? El then deja de estar disponible porque next() ya no retorna una promesa. La sintaxis se rompe y el flujo asincrónico desaparece.

¿Cómo recorrer un array con for await of?

La otra forma de iterar de manera asíncrona es con for await...of, que recorre estructuras iterables esperando cada valor antes de continuar.

js async function arrayOfNames(array) { for await (let value of array) { console.log(value); } }

const names = arrayOfNames(['Óscar', 'David', 'Ana']); console.log('after');

Al ejecutarlo verás primero after y luego los nombres. Eso confirma algo clave: el ciclo no bloquea el hilo principal. El programa sigue corriendo mientras el for await procesa los elementos uno a uno.

¿Por qué importan estas características en aplicaciones reales?

Cuando consumes APIs, manejas streams o lees archivos por chunks, necesitas controlar el cierre y la espera de cada operación. finally te ahorra repetición de código, mientras que las iteraciones asíncronas te permiten procesar colecciones donde cada elemento depende de una promesa.

Algunos casos donde lo vas a usar:

• Cerrar conexiones a bases de datos cuando termina una consulta.
• Ocultar indicadores de carga sin importar si la petición falló.
• Procesar listas de URLs y esperar la respuesta de cada una antes de seguir.

Prueba quitar el async, cambia los valores del array, mete un reject para forzar el catch y observa cómo finally se mantiene firme. Cuéntame en los comentarios qué resultado obtuviste cuando rompiste la sintaxis a propósito.