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):
- JavaScript ejecuta todo el código síncrono, de arriba hacia abajo.
- Los callbacks programados esperan en una cola.
- 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.