Programación asíncrona en JavaScript: guía completa para Node.js

Introducción a la programación asíncrona en JavaScript

JavaScript es un lenguaje de programación de un solo hilo con un modelo no bloqueante orientado a eventos. En el entorno Node.js, la programación asíncrona no es solo una opción conveniente, sino una necesidad fundamental. Sin asincronía, una aplicación de servidor se bloquearía en cada solicitud a la base de datos, lectura de archivo o llamada de red, haciéndola inadecuada para el trabajo real.

En esta guía, analizaremos tres paradigmas principales de programación asíncrona en JavaScript: Callback, Promise y async/await. Aprenderá cómo funciona el Event Loop, cómo manejar errores y escribir código legible y eficiente para Node.js.

1. Callback: la base de la asincronía

Un Callback (función de retrollamada) es una función que se pasa como argumento a otra función y se ejecuta después de que se completa una operación asíncrona. Este es el modelo de asincronía más antiguo y básico en JavaScript.

Ejemplo simple con Callback

const fs = require('fs');

// Lectura asíncrona de archivo con callbackfs.readFile('example.txt', 'utf8', (err, data) => {  if (err) {    console.error('Error al leer el archivo:', err);    return;  }  console.log('Contenido del archivo:', data);});

console.log('Lectura de archivo iniciada...');// Salida: "Lectura de archivo iniciada..." aparecerá antes que el contenido del archivo

En este ejemplo, la función callback se ejecutará solo después de que el archivo se haya leído por completo. Mientras tanto, el hilo principal continúa su ejecución: este es el comportamiento no bloqueante.

Callback Hell (Infierno de las retrollamadas)

La principal desventaja de los callbacks es la rápida pérdida de legibilidad con llamadas anidadas:

// Infierno de las retrollamadasgetUser(1, (err, user) => {  if (err) throw err;  getPosts(user.id, (err, posts) => {    if (err) throw err;    getComments(posts[0].id, (err, comments) => {      if (err) throw err;      console.log(user.name, posts[0].title, comments);    });  });});

Este código es difícil de depurar, mantener y ampliar. Afortunadamente, el JavaScript moderno ofrece soluciones mucho más elegantes.

2. Promise: promesa de un resultado

Una Promise (promesa) es un objeto que representa el resultado de una operación asíncrona, que puede estar completada (fulfilled), rechazada (rejected) o en espera (pending). Las promesas permiten evitar el anidamiento y construir cadenas de llamadas.

Creación y uso de Promise

// Función que devuelve una Promisefunction readFilePromise(filename) {  return new Promise((resolve, reject) => {    const fs = require('fs');    fs.readFile(filename, 'utf8', (err, data) => {      if (err) {        reject(err); // Error — promesa rechazada      } else {        resolve(data); // Éxito — promesa cumplida      }    });  });}

// Uso de la promesareadFilePromise('example.txt')  .then(data => {    console.log('Contenido:', data);    return data.length;  })  .then(length => {    console.log('Longitud del texto:', length);  })  .catch(err => {    console.error('Error:', err);  });

Métodos Promise.all y Promise.race

Promise.all permite esperar a que se cumplan todas las promesas, mientras que Promise.race espera la primera que se complete:

const p1 = readFilePromise('file1.txt');const p2 = readFilePromise('file2.txt');const p3 = readFilePromise('file3.txt');

// Esperamos los tres archivosPromise.all([p1, p2, p3])  .then(([data1, data2, data3]) => {    console.log('Todos los archivos cargados');    console.log(data1, data2, data3);  })  .catch(err => console.error('Error en uno de los archivos:', err));

// Esperamos el primero en completarsePromise.race([p1, p2, p3])  .then(firstResult => {    console.log('Primer archivo cargado:', firstResult);  });

3. Async/Await: estilo síncrono para código asíncrono