Promesas en Javascript: una aproximación rápida

Cuando hablamos de programación asíncrona en JavaScript, es fundamental hablar de la gestión de operaciones mediante promesas. Estas han venido a sustituir a los callback ya que disponen de una sintaxis bastante más clara y una gestión de errores más eficaz.

Pero, ¿qué son las Promesas?

Básicamente son objetos JavaScript que nos representan el éxito o el error de una operación que se haya realizado de forma asíncrona. Grosso modo: es un código que nos devuelve un resultado de la operación, tanto si esta ha sido un éxito o un error.

En el ejemplo a continuación, vamos a crear una promesa simple utilizando el constructor Promise.

Dentro de la función proporcionada al constructor, llevamos a cabo una operación asíncrona simulada y decidimos si la operación fue exitosa o por el contrario, tuvo algún error.

// Ejemplo de creación de una promesa simple
const miPromesa = new Promise((resolve, reject) => {
  // Operación asíncrona (de tipo que sea)
  const exito = true;

  if (exito) {
    resolve("La operación fue exitosa");
  } else {
    reject("La operación falló");
  }
});

Una vez que tenemos la promesa creada, como hemos visto, podemos manejarla mediante los métodos .then() o .catch() y trabajar con los resultados de esa promesa

// Uso de la promesa creada
miPromesa
  .then((mensaje) => console.log(mensaje))
  .catch((error) => console.error(error));

Con este ejemplo tan simple, hemos podido observar la flexibilidad de este tipo de estructuras a la hora de manejar eventos, que hacen que las promesas se hayan convertido en un estándar a la hora de gestionar operaciones de tipo asíncrono en JavaScript. La adopción de esta estructura, ha sido generalizada en el mundo del desarrollo, ya que permite mayor robustez y mejor mantenimiento.

Este tipo de objetos, permite el encadenamiento lo que facilita gestionar promesas consecutivas, como por ejemplo

// Ejemplo de encadenamiento de promesas
function realizarPrimeraOperacion() {
  return new Promise((resolve, reject) => {
    // Operación asíncrona simulada
    setTimeout(() => {
      const exito = true;
      if (exito) {
        resolve("Primera operación completada");
      } else {
        reject("Error en la primera operación");
      }
    }, 1000);
  });
}

function realizarSegundaOperacion(resultadoPrimera) {
  return new Promise((resolve, reject) => {
    // Operación asíncrona simulada
    setTimeout(() => {
      const exito = true;
      if (exito) {
        resolve(`Segunda operación completada con ${resultadoPrimera}`);
      } else {
        reject("Error en la segunda operación");
      }
    }, 1000);
  });
}

// Uso del encadenamiento de promesas
realizarPrimeraOperacion()
  .then((resultadoPrimera) => realizarSegundaOperacion(resultadoPrimera))
  .then((resultadoFinal) => console.log(resultadoFinal))
  .catch((error) => console.error("Error:", error));

En este ejemplo sencillo, la segunda operación se ejecutará solo si la primera operación se completa con éxito.

El encadenamiento mediante .then() facilita la lectura y comprensión del código.

Hasta aquí este pequeño post sobre las promesas en JavaScript. Si te apetece seguir leyendo sobre este tema, te recomiendo la documentación oficial del lenguaje, aquí.