Encadenamiento de Promesas en JavaScript

El encadenamiento de promesas es una técnica en JavaScript que permite ejecutar operaciones asíncronas de manera secuencial, donde cada operación se realiza una vez que la anterior ha terminado. Es ideal cuando se necesita realizar tareas que dependen del resultado de operaciones anteriores.

En este artículo aprenderás qué es el encadenamiento de promesas, cómo funciona y cómo utilizar then para pasar el resultado de una promesa a la siguiente.

¿Qué es el Encadenamiento de Promesas?

El encadenamiento de promesas permite ejecutar múltiples operaciones asíncronas una tras otra. Cada llamada a then devuelve una nueva promesa, lo que facilita pasar el resultado de una operación a la siguiente. Este patrón es muy útil para evitar la anidación de callbacks y lograr un código más limpio.

Ejemplo Básico de Encadenamiento

const promesa = new Promise((resolve) => {
  setTimeout(() => {
    resolve(10);
  }, 1000);
});

promesa
  .then((resultado) => {
    console.log("Primer resultado:", resultado);
    return resultado * 2;
  })
  .then((nuevoResultado) => {
    console.log("Segundo resultado:", nuevoResultado);
    return nuevoResultado + 5;
  })
  .then((final) => {
    console.log("Tercer resultado:", final);
  });

"Primer resultado:"
10
"Segundo resultado:"
20
"Tercer resultado:"
25

En el ejemplo anterior cada operación se encadena con then, donde el resultado de una promesa se pasa a la siguiente para continuar con el flujo.

¿Cómo Funciona el Encadenamiento?

El encadenamiento funciona porque el método then siempre devuelve una nueva promesa. Si la función proporcionada a then devuelve un valor, ese valor se envuelve en una promesa resuelta. Si devuelve otra promesa, el siguiente then espera a que esa promesa se resuelva.

1. Promesa con Valor Directo

Si el then devuelve un valor que no es una promesa, el valor se envuelve automáticamente en una promesa resuelta.

const promesa = new Promise((resolve) => resolve(5));

promesa
  .then((resultado) => resultado * 2)
  .then((doble) => console.log(doble));

10

2. Promesa que Devuelve Otra Promesa

Si el then devuelve una promesa, el siguiente then esperará hasta que esta se resuelva.

const promesa = new Promise((resolve) => resolve(10));

promesa
  .then((resultado) => {
    return new Promise((resolve) => {
      setTimeout(() => resolve(resultado * 3), 2000);
    });
  })
  .then((resultado) => console.log(resultado));  // Output: 30, después de 2 segundos

Casos en los que then no es Encadenamiento

Es importante entender que para que el encadenamiento sea efectivo, el then debe devolver un valor o una promesa. Si solo se llama al then sin devolver nada, la cadena se interrumpe.

Ejemplo de then sin Devolver Valor

const promesa = new Promise((resolve) => resolve(10));

promesa
  .then((resultado) => {
    console.log(resultado);  // Output: 10
    // No se devuelve nada aquí, por lo tanto, el encadenamiento se detiene
  })
  .then((resultado) => {
    console.log("Este código no se ejecutará");
  });

En este caso, el segundo then no tiene un valor previo para recibir por lo que el flujo no continúa.

Comparación: Múltiples then en la Misma Promesa vs. Encadenamiento

Es posible llamar a then varias veces sobre la misma promesa, pero no se considera un encadenamiento verdadero ya que cada then es independiente.

Ejemplo de Múltiples then en la Misma Promesa

let promesa = new Promise((resolve) => resolve(10));

promesa
  .then((resultado) => console.log(resultado))
  .then((resultado) => console.log(resultado))
  .then((resultado) => console.log(resultado));

10
undefined
undefined

En este ejemplo anterior los then no están encadenados porque no pasan el resultado a la siguiente operación. Cada then opera independientemente.

Buenas Prácticas para el Encadenamiento de Promesas

Para aprovechar al máximo el encadenamiento de promesas, ten en cuenta las siguientes recomendaciones:

1. Devuelve siempre un Valor o Promesa en then: Asegúrate de devolver algo en cada then para que el flujo continúe.
2. Evita Anidar then Dentro de Otro then: Encadena las promesas directamente para mantener un código limpio.
3. Maneja los Errores Adecuadamente: Utiliza catch para capturar errores en cualquier punto del encadenamiento.

Conclusión

El encadenamiento de promesas en JavaScript es una herramienta poderosa para ejecutar operaciones asíncronas de manera ordenada. Al utilizar then para pasar los resultados de una promesa a la siguiente, se puede evitar el “Callback Hell” y escribir código más legible y mantenible.

En el siguiente artículo exploraremos más técnicas avanzadas para manejar promesas y sus resultados de manera eficiente.