Saltar al contenido
Asincronía

Callbacks

Lección 3 de 99 min4 ejercicios

Antes de las promesas, la única forma de escribir código asíncrono era pasar una función que el runtime llamaría al terminar: un callback. Todavía aparece en todas partes (eventos, temporizadores, APIs antiguas de Node.js) y entender sus problemas es la mejor forma de entender por qué existen las promesas.

Avísame cuando termines

Una función asíncrona con callback recibe, además de sus datos, la función que debe llamar al terminar:

function prepararCafe(tipo, alTerminar) {
  console.log(`preparando ${tipo}…`);
  setTimeout(() => {
    alTerminar(`un ${tipo} caliente`);
  }, 200);
}

prepararCafe("cortado", (cafe) => console.log("listo:", cafe));
console.log("mientras, leo el diario");

Error primero

¿Cómo avisa una función con callback que algo salió mal? No puede lanzar un error, porque cuando falla ya nadie la está esperando en un try. Node.js popularizó una convención: el primer argumento del callback es el error (o null), y los siguientes, el resultado.

function buscarUsuario(id, cb) {
  setTimeout(() => {
    if (id <= 0) cb(new Error("id inválido"));
    else cb(null, { id, nombre: "Ana" });
  }, 50);
}

buscarUsuario(7, (error, usuario) => {
  if (error) return console.log("Falló:", error.message);
  console.log("Encontré a", usuario.nombre);
});

buscarUsuario(-1, (error, usuario) => {
  if (error) return console.log("Falló:", error.message);
  console.log("Encontré a", usuario.nombre);
});

Por qué try/catch no sirve

try {
  setTimeout(() => {
    throw new Error("¡ups!");
  }, 0);
} catch (e) {
  console.log("Nunca llego aquí");
}
console.log("el try ya terminó");

Cuando el callback lanza, el try terminó hace rato: el callback corre en otra vuelta del event loop, con la pila vacía. El error no tiene quién lo atrape y termina el programa. Con callbacks, los errores siempre se pasan como argumento.

El callback hell

Cuando cada paso depende del anterior, los callbacks se anidan:

buscarUsuario(7, (error, usuario) => {
  if (error) return manejar(error);
  buscarPedidos(usuario.id, (error, pedidos) => {
    if (error) return manejar(error);
    buscarDetalle(pedidos[0], (error, detalle) => {
      if (error) return manejar(error);
      calcularEnvio(detalle, (error, envio) => {
        if (error) return manejar(error);
        mostrar(envio);
      });
    });
  });
});

Es la pirámide de la perdición: el código se desplaza a la derecha, el manejo de errores se repite en cada nivel, y hacer dos cosas en paralelo o reintentar una se vuelve muy difícil. Hay otro problema, menos visible: le entregas tu función a código ajeno y confías en que la llame una vez, ni cero ni dos veces. Se llama inversión de control.

Resumen

  • Un callback es una función que se pasa para que la llamen cuando la tarea termine.
  • Convención error-first: (error, resultado); mira siempre primero el error.
  • try/catch no atrapa errores lanzados dentro de un callback asíncrono.
  • Anidar callbacks lleva al callback hell: difícil de leer, de manejar errores y de combinar.
  • Una función asíncrona debe llamar al callback siempre de forma asíncrona.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Avísame cuando termines

Elige una respuesta en cada pregunta.

  1. En la convención error-first de Node.js, ¿qué recibe primero el callback?

  2. ¿Qué es el callback hell?

  3. ¿Un try/catch alrededor de una función asíncrona atrapa un error lanzado dentro de su callback?

  4. [1, 2].map((n) => n * 2), ¿usa un callback asíncrono?

Ordena la salida: Error primero

Dos divisiones asíncronas, una de ellas imposible. Ordena lo que aparecería en la consola.

function dividir(a, b, cb) {  setTimeout(() => {    if (b === 0) cb(new Error("división por cero"));    else cb(null, a / b);  }, 10);} function mostrar(error, resultado) {  if (error) console.log("Error:", error.message);  else console.log("Resultado:", resultado);} dividir(10, 2, mostrar);dividir(1, 0, mostrar);console.log("pedidos enviados");

Consola, de arriba abajo

  1. Error: división por cero
  2. pedidos enviados
  3. Resultado: 5

Detective: Un try que llega tarde

Hay un try/catch, pero el error se escapa igual. Encuentra la línea y elige el arreglo.

Consola

config.js:7
    if (error) throw error;
               ^

Error: archivo no encontrado

Paso 1: toca la línea de código que causa el error.

Laboratorio: Una suma con callback

Escribe sumarLuego(a, b, cb) al estilo error-first, siempre asíncrona.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime sumas pedidas, el error y después 5 (pendiente)
  • El error es un TypeError y el éxito pasa null como error (pendiente)
  • El callback nunca se llama antes de que la función termine (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.