La diferencia entre promesa y espera asincrónica en Node.js

Hay diferentes formas de manejar las operaciones en NodeJS o en JavaScript. Para la ejecución asíncrona, diferentes procesos se ejecutan simultáneamente y se manejan una vez que el resultado de cada proceso está disponible. Hay diferentes formas de manejar el código asíncrono en NodeJS o en JavaScript que son:

• devoluciones de llamada
• promesas
• Asíncrono/Espera

1. Promesas:

Una promesa en NodeJS es similar a una promesa en la vida real. Es una garantía de que algo se hará. Promise se utiliza para realizar un seguimiento de si el evento asíncrono se ha ejecutado o no y determina qué sucede después de que se ha producido el evento. Es un objeto que tiene 3 estados a saber:

• Pendiente: Estado Inicial, antes de que haya ocurrido el evento.
• Resuelto: Después de que la operación se completó con éxito.
• Rechazado: Si la operación tuvo error durante la ejecución, la promesa falla.

Ejemplo: mientras se solicitan datos de un servidor de base de datos, la Promesa está en estado pendiente hasta que se reciben los datos. Si los datos se reciben correctamente, la Promesa se encuentra en estado resuelto y si los datos no se pueden recibir correctamente, la Promesa se encuentra en estado rechazado. 

Manejo de errores de promesas: para una promesa resuelta con éxito, usamos el método .then() y para una promesa rechazada, usamos el método .catch(). Para ejecutar un código después de que se haya manejado la promesa usando el método .then() o .catch(), podemos usar el método .finally(). El código dentro del método .finally() se ejecuta una vez independientemente del estado de la promesa.

Ejemplo:

<script>
  const promise = new Promise(function (resolve, reject) {
    const string1 = "geeksforgeeks";
    const string2 = "geeksforgeeks";
    if (string1 === string2) {
      resolve();
    } else {
      reject();
    }
  });
 
  promise
    .then(function () {
      console.log("Promise resolved successfully");
    })
    .catch(function () {
      console.log("Promise is rejected");
    });
</script>

Producción:

Promise resolved successfully

2. Asíncrono/Espera:

Async/Await se usa para trabajar con promesas en funciones asíncronas. Es básicamente azúcar sintáctico para promesas. Es solo un contenedor para cambiar el estilo del código y hacer que las promesas sean más fáciles de leer y usar. Hace que el código asincrónico se parezca más a un código sincrónico/de procedimiento, que es más fácil de entender.

await solo se puede usar en funciones asíncronas. Se utiliza para llamar a una función asíncrona y espera a que se resuelva o rechace. await bloquea la ejecución del código dentro de la función asíncrona en la que se encuentra. 

Manejo de errores en Async/Await: para una promesa resuelta con éxito, usamos try y para una promesa rechazada, usamos catch. Para ejecutar un código después de que se haya manejado la promesa usando try o catch, podemos usar el método .finally(). El código dentro del método .finally() se ejecuta una vez independientemente del estado de la promesa.

Ejemplo:

<script>
  const helperPromise = function () {
    const promise = new Promise(function (resolve, reject) {
      const x = "geeksforgeeks";
      const y = "geeksforgeeks";
      if (x === y) {
        resolve("Strings are same");
      } else {
        reject("Strings are not same");
      }
    });
 
    return promise;
  };
 
  async function demoPromise() {
    try {
      let message = await helperPromise();
      console.log(message);
    } catch (error) {
      console.log("Error: " + error);
    }
  }
 
  demoPromise();
</script>

Producción:

Strings are same

Diferencia entre Promise y Async/Await: