Promesas con mejor cara
async y await no reemplazan a las promesas: son una forma más cómoda de usarlas. Comparemos. Con then:
function mostrarPedido() {
return obtenerUsuario(1)
.then((usuario) => obtenerPedidos(usuario))
.then((pedidos) => console.log(pedidos.length));
}
Con async/await:
async function mostrarPedido() {
const usuario = await obtenerUsuario(1);
const pedidos = await obtenerPedidos(usuario);
console.log(pedidos.length);
}
Hace lo mismo, pero se lee de arriba hacia abajo, como código normal.
async
Poner async delante de una función tiene dos efectos:
- Permite usar
awaitdentro de ella. - Hace que siempre devuelva una promesa. Si devuelves un valor, se envuelve en una promesa cumplida; si lanzas un error, en una rechazada.
async function numero() {
return 7;
}
numero().then((n) => console.log(n)); // 7
También funciona con flechas: const cargar = async () => { ... };.
await
await va delante de una promesa. Pausa la función hasta que la promesa se cumple y devuelve su valor:
const esperar = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
async function proceso() {
console.log("Empieza");
await esperar(50);
console.log("Pasaron 50 ms");
}
proceso();
console.log("Esto sale antes de los 50 ms");
// Empieza
// Esto sale antes de los 50 ms
// Pasaron 50 ms
Fíjate en el orden: await pausa solo la función proceso, no todo el programa. Mientras espera, el resto del código sigue.
Manejar errores con try/catch
Si la promesa que esperas se rechaza, await lanza el error, como si fuera un throw. Eso significa que vuelves a usar el try/catch de siempre:
async function consultar(ciudad) {
try {
const clima = await obtenerClima(ciudad);
console.log("Clima: " + clima);
} catch (error) {
console.log("Error: " + error.message);
} finally {
console.log("Consulta terminada");
}
}
Secuencial o en paralelo
Cada await espera a que termine el anterior. Si las tareas dependen una de otra, eso es lo correcto. Pero si son independientes, estás perdiendo tiempo:
// Secuencial: unos 300 ms en total
const a = await tarea(100);
const b = await tarea(200);
Para que corran a la vez, inícialas todas y espera el conjunto con Promise.all:
// En paralelo: unos 200 ms en total
const [a, b] = await Promise.all([tarea(100), tarea(200)]);
Aquí la desestructuración de arrays separa los resultados en variables.
await dentro de bucles
Un for...of con await procesa los elementos uno tras otro, en orden:
async function procesarTodos(ids) {
for (const id of ids) {
const dato = await cargar(id);
console.log(dato);
}
}
Si el orden no importa y quieres velocidad, usa Promise.all(ids.map(cargar)).
Resumen
| Quieres... | Escribe |
|---|---|
| Esperar una promesa | const x = await promesa; |
| Capturar su error | try { await ... } catch (e) { ... } |
| Varias en paralelo | await Promise.all([p1, p2]) |
| Varias en orden | for (const x of lista) { await ... } |