Compara callbacks, Promises y async/await.

Question

Accepted Answer

Estas son tres generaciones de manejo de operaciones **asíncronas** en Node — cada una mejora la legibilidad respecto a la anterior, pero todas se construyen sobre la misma base del event loop.

## 1. Callbacks — el original (y el "callback hell")

```js
fs.readFile("a.txt", (err, a) => {
  if (err) return handle(err);            // convención de callback con error primero
  fs.readFile("b.txt", (err, b) => {       // el anidamiento se profundiza con cada paso...
    if (err) return handle(err);
    db.save(a + b, (err) => {              // "pirámide de la perdición"
      if (err) return handle(err);
    });
  });
});
```

La convención de Node es **callbacks con error primero** (`(err, result)`). Funcionan, pero se anidan profundamente y dispersan el manejo de errores — difíciles de leer y mantener.

## 2. Promises — encadenables, más planas

```js
readFile("a.txt")
  .then(a => readFile("b.txt").then(b => a + b)) // devuelve una promise → la cadena espera
  .then(combined => db.save(combined))
  .catch(handle);                                 // UN solo lugar para todos los errores
```

Una Promise representa un valor futuro; `.then` encadena pasos y `.catch` maneja cualquier error de la cadena — más plano que los callbacks anidados.

## 3. async/await — con apariencia síncrona (el estándar moderno)

```js
async function combine() {
  try {
    const a = await readFile("a.txt");   // pausa hasta que se resuelva
    const b = await readFile("b.txt");
    await db.save(a + b);
  } catch (err) {
    handle(err);                          // el try/catch normal funciona
  }
}
```

`async/await` es azúcar sintáctico sobre las Promises — se lee de arriba a abajo como código síncrono, usa el `try/catch` habitual y es el estilo moderno recomendado.

## No serialices trabajo independiente

```js
// ❌ secuencial — lento
const a = await getA(); const b = await getB();
// ✅ en paralelo — ambos a la vez
const [a, b] = await Promise.all([getA(), getB()]);
```

## La relación

```text
Callbacks → Promises → async/await
Todos usan el event loop. Las Promises envuelven callbacks; async/await envuelve Promises.
Código moderno: async/await, con Promise.all para paralelizar operaciones independientes.
```

## Por qué es importante

El manejo asíncrono es inevitable en Node (todo el I/O es asíncrono).

Entender la progresión — callbacks con error primero (aún comunes en APIs/librerías antiguas), Promises (encadenables) y async/await (legible, el estándar) — te permite leer cualquier base de código y escribir lógica asíncrona limpia.

Saber que todos son el mismo mecanismo del event loop por debajo, y recordar paralelizar operaciones independientes con `Promise.all`, es clave para un código Node asíncrono correcto y eficiente.