Saltar al contenido

Sección 5: Asincronía, 0 de 3 lecciones completadas

Lección 18 de 22Asincronía

async y await

  • 6 min de lectura
  • 3 ejercicios

Escribe código asíncrono que se lee como síncrono con async y await. Maneja errores con try/catch y combina await con Promise.all para tareas en paralelo.

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:

  1. Permite usar await dentro de ella.
  2. 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 ... }

Puntos clave

  • Una función async siempre devuelve una promesa.
  • await pausa la función async hasta que la promesa se cumple y entrega su valor.
  • Mientras una función espera, el resto del programa sigue funcionando.
  • Con async/await, los errores de las promesas se capturan con try/catch normal.
  • Para tareas independientes, combina await con Promise.all en vez de esperar una por una.

Hora de practicar

Ejercicios

0/3 resueltos

Reto 1 de 3

Ejercicio 1: Tu primer await

Completa la función async saludarLuego(nombre): debe esperar con await a que esperar(20) termine y después devolver el texto "Hola, " + nombre.

El código de abajo ya la usa. La salida debe ser:

Hola, Martina
const esperar = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// TODO: convierte saludarLuego en una función async
// TODO: espera esperar(20) con await y devuelve el saludo
function saludarLuego(nombre) {
}

saludarLuego("Martina").then((saludo) => console.log(saludo));

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 2 de 3

Ejercicio 2: Errores con try/catch

obtenerSaldo(cuenta) devuelve una promesa que se rechaza si la cuenta no existe. Completa mostrarSaldo(cuenta) con await y try/catch para mostrar "Saldo: " más el saldo, o "Error: " más el mensaje del error.

La salida debe ser:

Saldo: 350
Error: Cuenta inexistente
const saldos = { A1: 350 };

function obtenerSaldo(cuenta) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (cuenta in saldos) resolve(saldos[cuenta]);
      else reject(new Error("Cuenta inexistente"));
    }, 10);
  });
}

async function mostrarSaldo(cuenta) {
  // TODO: espera obtenerSaldo(cuenta) dentro de un try
  // TODO: en el catch, muestra "Error: " + error.message
}

async function main() {
  await mostrarSaldo("A1");
  await mostrarSaldo("Z9");
}

main();

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 3 de 3

Ejercicio 3: Cargar en paralelo

Completa cargarPerfil() para que pida el usuario y sus amigos a la vez con await Promise.all, y devuelva el texto "Ana tiene 3 amigos". Cada consulta tarda 40 ms: hechas en paralelo, el total tarda unos 40 ms; una tras otra, unos 80.

El código de abajo mide el tiempo. La salida debe ser:

Ana tiene 3 amigos
En paralelo
const esperar = (ms, valor) => new Promise((resolve) => setTimeout(() => resolve(valor), ms));
const obtenerUsuario = () => esperar(40, { nombre: "Ana" });
const obtenerAmigos = () => esperar(40, ["Luis", "Eva", "Sara"]);

async function cargarPerfil() {
  // TODO: usa await Promise.all para pedir usuario y amigos a la vez
  // TODO: devuelve "<nombre> tiene <cantidad> amigos"
}

const inicio = Date.now();
cargarPerfil().then((texto) => {
  console.log(texto);
  console.log(Date.now() - inicio < 70 ? "En paralelo" : "En secuencia");
});

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Has llegado al final de «Asincronía». Haz el examen de la sección.

¿Has encontrado un error en esta lección? Avísanos