Quali tipi di Promise conosci?

Principali tipi di promesse in Node.js:

• Promise di base: Rappresenta un contenitore per valori futuri o errori. Ha tre stati: pending (in attesa), fulfilled (completato con successo), rejected (rifiutato). Viene creato con il costruttore new Promise().

  // Creazione di una promessa di base
  const myPromise = new Promise((resolve, reject) => {
    // Operazione asincrona
    setTimeout(() => {
      const success = true;
      if (success) {
        resolve("Operazione completata con successo");
      } else {
        reject("Si è verificato un errore");
      }
    }, 1000);
  });
  

• Promise.resolve(): Crea una promessa che passa immediatamente allo stato fulfilled con un valore dato.

  // Creazione di una promessa risolta
  const resolvedPromise = Promise.resolve("Questa è già una promessa risolta");
  

• Promise.reject(): Crea una promessa che passa immediatamente allo stato rejected con una causa di errore data.

  // Creazione di una promessa rifiutata
  const rejectedPromise = Promise.reject(new Error("Questa è una promessa rifiutata"));
  

• Promise.all(): Prende un array di promesse e restituisce una nuova promessa. Passa allo stato fulfilled quando tutte le promesse dell'array sono completate con successo. Il valore sarà un array di risultati nello stesso ordine delle promesse di input. Se qualcuna delle promesse viene rifiutata, Promise.all() viene rifiutata immediatamente con la causa della prima promessa rifiutata.

  // Uso di 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 sarà [1, 2, 3]
    })
    .catch((error) => {
      // Gestione degli errori
    });
  

• Promise.allSettled(): Prende un array di promesse e restituisce una nuova promessa. Passa allo stato fulfilled quando tutte le promesse dell'array sono concluse, con successo (fulfilled) o rifiutate (rejected). Il valore sarà un array di oggetti che descrivono il risultato di ogni promessa (stato e valore/causa). A differenza di Promise.all(), non si rifiuta immediatamente.

  // Uso di Promise.allSettled()
  const promiseA = Promise.resolve("successo");
  const promiseB = Promise.reject("errore");
  Promise.allSettled([promiseA, promiseB])
    .then((results) => {
      // results sarà un array di oggetti:
      // [{status: 'fulfilled', value: 'successo'}, {status: 'rejected', reason: 'errore'}]
    });
  

• Promise.race(): Prende un array di promesse e restituisce una nuova promessa. La nuova promessa passa allo stato fulfilled o rejected con il risultato/causa della prima promessa che si risolve o si rifiuta.

  // Uso di Promise.race()
  const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("Sono veloce!"), 50));
  const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Sono lento..."), 500));
  Promise.race([promiseFast, promiseSlow])
    .then((value) => {
      // value sarà "Sono veloce!"
    });
  

• Promise.any(): Prende un array di promesse e restituisce una nuova promessa. La promessa passa allo stato fulfilled con il valore della prima promessa che si completa con successo. Se tutte le promesse vengono rifiutate, Promise.any() restituisce un errore AggregateError che contiene le cause di tutte le promesse rifiutate. Disponibile a partire da Node.js 12.

  // Uso di Promise.any()
  const promiseFail1 = Promise.reject("Errore 1");
  const promiseSuccess = Promise.resolve("Successo!");
  const promiseFail2 = Promise.reject("Errore 2");
  Promise.any([promiseFail1, promiseSuccess, promiseFail2])
    .then((value) => {
      // value sarà "Successo!"
    })
    .catch((error) => {
      // Gestione di AggregateError se tutte le promesse vengono rifiutate
    });