¿Qué tipos de Promise conoces?

Principales tipos de promesas en Node.js:

• Promise Básico: Es un contenedor para valores futuros o errores. Tiene tres estados: pending (pendiente), fulfilled (cumplido), rejected (rechazado). Se crea con el constructor new Promise().

  // Creando una promesa básica
  const myPromise = new Promise((resolve, reject) => {
    // Operación asíncrona
    setTimeout(() => {
      const success = true;
      if (success) {
        resolve("Operación completada con éxito");
      } else {
        reject("Ocurrió un error");
      }
    }, 1000);
  });
  

• Promise.resolve(): Crea una promesa que pasa inmediatamente al estado fulfilled con un valor dado.

  // Creando una promesa resuelta
  const resolvedPromise = Promise.resolve("Esta ya es una promesa cumplida");
  

• Promise.reject(): Crea una promesa que pasa inmediatamente al estado rejected con una razón de error dada.

  // Creando una promesa rechazada
  const rejectedPromise = Promise.reject(new Error("Esta promesa fue rechazada"));
  

• Promise.all(): Toma un array de promesas y devuelve una nueva promesa. Esta nueva promesa pasa a estado fulfilled cuando todas las promesas en el array se completan con éxito. El valor será un array de resultados en el mismo orden que las promesas de entrada. Si cualquiera de las promesas en el array se rechaza, Promise.all() se rechaza inmediatamente con la razón de la primera promesa rechazada.

  // Uso de Promise.all()
  const promise1 = Promise.resolve(1);
  const promise2 = Promise.resolve(2);
  const promise3 = new Promise((resolve, reject) => setTimeout(() => resolve(3), 100));
  Promise.all([promise1, promise2, promise3])
    .then((values) => {
      // values será [1, 2, 3]
    })
    .catch((error) => {
      // Manejo de errores
    });
  

• Promise.allSettled(): Toma un array de promesas y devuelve una nueva promesa. Esta pasa a estado fulfilled cuando todas las promesas en el array se completan, ya sea con éxito (fulfilled) o con rechazo (rejected). El valor será un array de objetos que describen el resultado de cada promesa (estado y valor/razón). A diferencia de Promise.all(), no se rechaza inmediatamente.

  // Uso de Promise.allSettled()
  const promiseA = Promise.resolve("éxito");
  const promiseB = Promise.reject("error");
  Promise.allSettled([promiseA, promiseB])
    .then((results) => {
      // results será un array de objetos:
      // [{status: 'fulfilled', value: 'éxito'}, {status: 'rejected', reason: 'error'}]
    });
  

• Promise.race(): Toma un array de promesas y devuelve una nueva promesa. La nueva promesa pasa a estado fulfilled o rejected con el resultado/razón de la primera promesa del array que se complete, ya sea con éxito o rechazo.

  // Uso de Promise.race()
  const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("¡Soy rápido!"), 50));
  const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Soy lento..."), 500));
  Promise.race([promiseFast, promiseSlow])
    .then((value) => {
      // value será "¡Soy rápido!"
    });
  

• Promise.any(): Toma un array de promesas y devuelve una nueva promesa. La promesa pasa a estado fulfilled con el valor de la primera promesa que se complete con éxito. Si todas las promesas se rechazan, Promise.any() devuelve un error AggregateError que contiene las razones de todas las promesas rechazadas. Disponible desde Node.js 12.

  // Uso de Promise.any()
  const promiseFail1 = Promise.reject("Error 1");
  const promiseSuccess = Promise.resolve("¡Éxito!");
  const promiseFail2 = Promise.reject("Error 2");
  Promise.any([promiseFail1, promiseSuccess, promiseFail2])
    .then((value) => {
      // value será "¡Éxito!"
    })
    .catch((error) => {
      // Manejo de AggregateError si todas las promesas se rechazan
    });