Saltar al contenido

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

Lección 16 de 22Asincronía

setTimeout y callbacks

  • 6 min de lectura
  • 3 ejercicios

Entiende la asincronía en JavaScript: por qué el código no siempre corre en orden, cómo funcionan setTimeout y el bucle de eventos y qué es el callback hell.

Tareas que tardan

Algunas operaciones no terminan al instante: pedir datos a un servidor, leer un archivo, esperar a que el usuario haga clic. Si JavaScript se quedara esperando sin hacer nada, la página entera se congelaría.

JavaScript ejecuta una sola cosa a la vez (se dice que tiene un solo hilo). Para no bloquearse, delega las esperas: «avísame cuando esto termine» y, mientras tanto, sigue con lo demás. A ese estilo de programación se le llama asíncrono.

setTimeout

La forma más simple de ver la asincronía es setTimeout(funcion, milisegundos): programa una función para que se ejecute después de un tiempo.

console.log("1. Pido un café");

setTimeout(() => {
  console.log("3. El café está listo");
}, 1000);

console.log("2. Mientras tanto, leo el periódico");
1. Pido un café
2. Mientras tanto, leo el periódico
3. El café está listo

El setTimeout no detiene el programa: registra la función y sigue de inmediato a la línea siguiente. Un segundo después, se ejecuta la función.

Incluso con 0 milisegundos

setTimeout(() => console.log("B"), 0);
console.log("A");
// A
// B

Aunque el tiempo sea 0, «B» sale después. La razón es el bucle de eventos (event loop):

  1. JavaScript ejecuta todo el código síncrono, de arriba hacia abajo.
  2. Los callbacks programados esperan en una cola.
  3. Solo cuando el código síncrono terminó, el bucle de eventos toma el siguiente callback de la cola y lo ejecuta.

El tiempo de setTimeout es un mínimo, no una garantía: si el código síncrono tarda, el callback espera.

Cancelar un temporizador

setTimeout devuelve un identificador que puedes pasar a clearTimeout para cancelarlo. Y setInterval repite la función cada cierto tiempo, hasta que lo detienes con clearInterval:

let vueltas = 0;
const id = setInterval(() => {
  vueltas++;
  console.log("tic " + vueltas);
  if (vueltas === 3) clearInterval(id);
}, 10);
// tic 1, tic 2, tic 3

Callbacks

Ya viste que una función puede recibir otra como argumento. En el código asíncrono, ese callback es la forma de decir «cuando termines, llama a esto»:

function prepararPedido(plato, alTerminar) {
  console.log("Preparando " + plato + "...");
  setTimeout(() => {
    alTerminar(plato + " listo");
  }, 50);
}

prepararPedido("lomo saltado", (resultado) => {
  console.log(resultado);
});
// Preparando lomo saltado...
// lomo saltado listo

La función no puede devolver el resultado con return, porque cuando el resultado existe, la función ya terminó. Por eso lo entrega llamando al callback.

Errores en callbacks

Por convención (sobre todo en Node.js), el primer parámetro del callback es el error, o null si todo salió bien:

function dividirLuego(a, b, callback) {
  setTimeout(() => {
    if (b === 0) {
      callback(new Error("División entre cero"), null);
    } else {
      callback(null, a / b);
    }
  }, 10);
}

dividirLuego(10, 2, (error, resultado) => {
  if (error) {
    console.log(error.message);
    return;
  }
  console.log(resultado); // 5
});

try/catch no sirve aquí: cuando el callback se ejecuta, el try ya terminó hace rato.

El callback hell

Si cada paso depende del anterior, los callbacks se anidan unos dentro de otros:

obtenerUsuario(1, (usuario) => {
  obtenerPedidos(usuario, (pedidos) => {
    obtenerDetalle(pedidos[0], (detalle) => {
      calcularEnvio(detalle, (envio) => {
        console.log(envio);
      });
    });
  });
});

Esta «pirámide» es difícil de leer y de manejar cuando hay errores en cada nivel. Se la conoce como callback hell, y es exactamente el problema que resuelven las promesas, el tema de la próxima lección.

Puntos clave

  • JavaScript ejecuta una cosa a la vez, pero puede dejar tareas programadas para después.
  • setTimeout(funcion, ms) ejecuta la función cuando pasa el tiempo indicado, sin bloquear.
  • El código síncrono siempre termina antes de que corra cualquier callback, incluso con 0 ms.
  • Un callback es una función que entregas para que se llame cuando algo termine.
  • Anidar muchos callbacks crea el callback hell; las promesas lo resuelven.

Hora de practicar

Ejercicios

0/3 resueltos

Reto 1 de 3

Ejercicio 1: Ordena la ejecución

Sin cambiar el texto de ningún mensaje, coloca los tres console.log (directamente o dentro de setTimeout) para que la salida sea:

Inicio
Fin
Después de 20 ms

El último mensaje debe mostrarse con un setTimeout de 20 ms.

// TODO: muestra "Después de 20 ms" con un setTimeout de 20 ms
console.log("Después de 20 ms");
console.log("Inicio");
console.log("Fin");

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

Reto 2 de 3

Ejercicio 2: Cuenta regresiva

Completa cuentaRegresiva(desde, alTerminar): debe mostrar los números desde desde hasta 1, uno cada 10 ms, y después llamar al callback alTerminar. Usa setTimeout (o setInterval). La salida debe ser:

3
2
1
¡Despegue!
function cuentaRegresiva(desde, alTerminar) {
  // TODO: muestra desde, desde - 1, ..., 1, uno cada 10 ms
  // TODO: al final, llama a alTerminar()
}

cuentaRegresiva(3, () => console.log("¡Despegue!"));

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

Reto 3 de 3

Ejercicio 3: Callback con error

Completa buscarProducto(id, callback) siguiendo la convención «error primero». Tras 10 ms:

  • si el producto existe en catalogo, llama a callback(null, producto);
  • si no, llama a callback(new Error("Producto no encontrado")).

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

Encontrado: Lámpara
Error: Producto no encontrado
const catalogo = { 1: "Silla", 2: "Lámpara" };

function buscarProducto(id, callback) {
  // TODO: tras 10 ms, llama a callback(null, producto) o callback(new Error(...))
}

buscarProducto(2, (error, producto) => {
  if (error) return console.log("Error: " + error.message);
  console.log("Encontrado: " + producto);
});

setTimeout(() => {
  buscarProducto(9, (error, producto) => {
    if (error) return console.log("Error: " + error.message);
    console.log("Encontrado: " + producto);
  });
}, 30);

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

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