Enstringmiento de promesas de JavaScript

En este artículo, discutiremos cómo realizar Promise Chaining en JavaScript. Una promesa es básicamente un objeto que representa la finalización (o falla) de una operación asincrónica junto con su resultado. 

Una promesa tiene 3 tipos de estados y, en función de estos estados, la promesa ejecuta los resultados.

• Pendiente: este estado representa un estado inicial, un estado cumplido o un estado rechazado.
• Cumplido: este estado representa que la operación asincrónica se completó con éxito.
• Rechazado: este estado representa que se rechaza la operación asincrónica.

Una Promesa se ejecuta usando el método .then() escrito después de la promesa declarada. Si necesitamos manejar cualquier error que ocurra, entonces usamos el método .catch() escrito después de la promesa. También usamos el método .finally() si solo queremos imprimir nuestro resultado independientemente de cualquier error que haya ocurrido durante la ejecución de la promesa.

Declarando una Promesa: Podemos declarar la promesa usando la siguiente sintaxis.

let promise =  new Promise((resolve , reject)=>{
                resolve('Hello JavaScript !');
});

Como puede ver en la sintaxis anterior, hay una función de devolución de llamada que se pasa dentro de un objeto de promesa que toma dos métodos como argumento. Primero, uno es resolve(), que es responsable de la finalización exitosa de cualquier texto o ejecutable que se pase dentro de él. 

El segundo es el rechazo(), que es responsable de la finalización fallida de una operación, y podemos pasar texto dentro de él, que se muestra junto con nuestro error.

Ejecutando una Promesa: Podemos ejecutar la promesa usando la siguiente sintaxis.

• Método 1:

  JavaScript

  <script> let promise = new Promise((resolve, reject) => {   resolve("Hello JavaScript !"); });    promise.then((result) => console.log(result)); </script>

  Salida: se muestra arriba que la variable de resultado se usa para consolar el resultado que proviene del método resolve() .

  Hello JavaScript !

• Método 2:

  JavaScript

  <script>let promise = new Promise((resolve, reject) => {   resolve("Hello JavaScript !"); });    promise.then((result) => {   console.log(result); }); </script>

  Salida: en este método, se pasa una función de devolución de llamada dentro del método .then() . En la función de devolución de llamada, se declara la variable de resultado, que es responsable de imprimir el resultado que proviene del método resolve() .

  Hello JavaScript !

Promise Chaining: Promise Chaining es un concepto simple mediante el cual podemos inicializar otra promesa dentro de nuestro método .then() y, en consecuencia, podemos ejecutar nuestros resultados.

La sintaxis para usar el enstringmiento de promesas es la siguiente.

<script>
let promise = new Promise((resolve, reject) => {
  resolve("Hello JavaScript");
});
promise
  .then(
    new Promise((resolve, reject) => {
      resolve("Hello GeeksforGeeks");
    }).then((result1) => {
      console.log(result1);
    })
  )
  .then((result2) => {
    console.log(result2);
  });
</script>

Salida: como se ilustra arriba, mientras ejecutamos la promesa declarada, estamos pasando otra promesa dentro de .then() y ejecutando nuestros resultados en consecuencia.

Hello GeeksforGeeks 
Hello JavaScript

Nota: también puede declarar varias promesas dentro de .then() y ejecutar sus resultados en consecuencia.