Gestione degli errori in Promise.all

Ho una serie di promesse con cui sto risolvendo Promise.all(arrayOfPromises);

Continuo per continuare la catena di promesse. Sembra qualcosa del genere

existingPromiseChain = existingPromiseChain.then(function() {
  var arrayOfPromises = state.routes.map(function(route){
    return route.handler.promiseHandler();
  });
  return Promise.all(arrayOfPromises)
});

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
  // do stuff with my array of resolved promises, eventually ending with a res.send();
});

Voglio aggiungere una dichiarazione catch per gestire una promessa individuale nel caso in cui si verifichi un errore, ma quando provo Promise.allrestituisce il primo errore che trova (ignora il resto), quindi non riesco a ottenere i dati dal resto delle promesse in l'array (che non ha dato errori).

Ho provato a fare qualcosa come ..

existingPromiseChain = existingPromiseChain.then(function() {
      var arrayOfPromises = state.routes.map(function(route){
        return route.handler.promiseHandler()
          .then(function(data) {
             return data;
          })
          .catch(function(err) {
             return err
          });
      });
      return Promise.all(arrayOfPromises)
    });

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
      // do stuff with my array of resolved promises, eventually ending with a res.send();
});

Ma questo non si risolve.

Grazie!

-

Modificare:

Ciò che le risposte sotto riportate erano completamente vere, il codice si stava rompendo per altri motivi. Nel caso qualcuno fosse interessato, questa è la soluzione con cui ho finito ...

Catena di server Express Node

serverSidePromiseChain
    .then(function(AppRouter) {
        var arrayOfPromises = state.routes.map(function(route) {
            return route.async();
        });
        Promise.all(arrayOfPromises)
            .catch(function(err) {
                // log that I have an error, return the entire array;
                console.log('A promise failed to resolve', err);
                return arrayOfPromises;
            })
            .then(function(arrayOfPromises) {
                // full array of resolved promises;
            })
    };

Chiamata API (chiamata route.async)

return async()
    .then(function(result) {
        // dispatch a success
        return result;
    })
    .catch(function(err) {
        // dispatch a failure and throw error
        throw err;
    });

Mettere il .catchfor Promise.allprima del .thensembra aver servito allo scopo di catturare eventuali errori dalle promesse originali, ma poi riportare l'intero array al successivo.then

Grazie!

Promise.allè tutto o niente. Si risolve una volta che tutte le promesse nell'array vengono risolte o rifiutate non appena una di esse viene rifiutata . In altre parole, o si risolve con un array di tutti i valori risolti o rifiuta con un singolo errore.

Alcune librerie hanno qualcosa chiamato Promise.when, che a mio avviso aspetterebbe invece che tutte le promesse nell'array si risolvano o rifiutino, ma non ne ho familiarità, e non è in ES6.

Il tuo codice

Sono d'accordo con altri qui che la tua correzione dovrebbe funzionare. Dovrebbe risolversi con un array che può contenere una combinazione di valori riusciti e oggetti errori. È insolito passare oggetti di errore nel percorso di successo, ma supponendo che il codice li stia aspettando, non vedo alcun problema.

L'unica ragione per cui riesco a pensare al motivo per cui "non si risolverà" è che non ci riesce nel codice che non ci stai mostrando e il motivo per cui non vedi alcun messaggio di errore a riguardo è perché questa catena di promesse non è terminata con un finale cattura (per quanto ci stai mostrando comunque).

Mi sono preso la libertà di prendere in considerazione la "catena esistente" dal tuo esempio e di terminare la catena con un fermo. Questo potrebbe non essere giusto per te, ma per le persone che leggono questo, è importante restituire o terminare sempre le catene, oppure i potenziali errori, anche gli errori di codifica, verranno nascosti (che è ciò che sospetto sia successo qui):

Promise.all(state.routes.map(function(route) {
  return route.handler.promiseHandler().catch(function(err) {
    return err;
  });
}))
.then(function(arrayOfValuesOrErrors) {
  // handling of my array containing values and/or errors. 
})
.catch(function(err) {
  console.log(err.message); // some coding error in handling happened
});

NUOVA RISPOSTA

const results = await Promise.all(promises.map(p => p.catch(e => e)));
const validResults = results.filter(result => !(result instanceof Error));

API FUTURE Promise

• Chrome 76: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
• Puoi scaricare https://www.npmjs.com/package/promise.allsettled per ottenerlo ora. In alcuni browser allSettled viene preinstallato con il browser stesso. Vale la pena scaricare il pacchetto per la massima tranquillità perché ad es. TypeScript non ha definizioni predefinite per allSettled.

Per continuare il Promise.allciclo (anche quando una Promessa rifiuta) ho scritto una funzione di utilità che viene chiamata executeAllPromises. Questa funzione di utilità restituisce un oggetto con resultse errors.

L'idea è che tutte le Promesse a cui passerai executeAllPromisessaranno inserite in una nuova Promessa che si risolverà sempre. La nuova Promessa si risolve con un array che ha 2 punti. Il primo punto contiene il valore di risoluzione (se presente) e il secondo punto mantiene l'errore (se la Promessa spostata rifiuta).

Come passaggio finale, executeAllPromisesaccumula tutti i valori delle promesse spostate e restituisce l'oggetto finale con una matrice per resultse una matrice per errors.

Ecco il codice:

function executeAllPromises(promises) {
  // Wrap all Promises in a Promise that will always "resolve"
  var resolvingPromises = promises.map(function(promise) {
    return new Promise(function(resolve) {
      var payload = new Array(2);
      promise.then(function(result) {
          payload[0] = result;
        })
        .catch(function(error) {
          payload[1] = error;
        })
        .then(function() {
          /* 
           * The wrapped Promise returns an array:
           * The first position in the array holds the result (if any)
           * The second position in the array holds the error (if any)
           */
          resolve(payload);
        });
    });
  });

  var errors = [];
  var results = [];

  // Execute all wrapped Promises
  return Promise.all(resolvingPromises)
    .then(function(items) {
      items.forEach(function(payload) {
        if (payload[1]) {
          errors.push(payload[1]);
        } else {
          results.push(payload[0]);
        }
      });

      return {
        errors: errors,
        results: results
      };
    });
}

var myPromises = [
  Promise.resolve(1),
  Promise.resolve(2),
  Promise.reject(new Error('3')),
  Promise.resolve(4),
  Promise.reject(new Error('5'))
];

executeAllPromises(myPromises).then(function(items) {
  // Result
  var errors = items.errors.map(function(error) {
    return error.message
  }).join(',');
  var results = items.results.join(',');
  
  console.log(`Executed all ${myPromises.length} Promises:`);
  console.log(`— ${items.results.length} Promises were successful: ${results}`);
  console.log(`— ${items.errors.length} Promises failed: ${errors}`);
});

ES2020 introduce un nuovo metodo per il tipo Promise: Promise.allSettled()
Promise.allSettled ti dà un segnale quando tutte le promesse di input sono definite, il che significa che sono state soddisfatte o rifiutate. Ciò è utile nei casi in cui non ti interessa lo stato della promessa, vuoi solo sapere quando il lavoro è finito, indipendentemente dal fatto che abbia avuto successo.

const promises = [
  fetch('/api-call-1'),
  fetch('/api-call-2'),
  fetch('/api-call-3'),
];
// Imagine some of these requests fail, and some succeed.

const result = await Promise.allSettled(promises);
console.log(result.map(x=>s.status));
// ['fulfilled', 'fulfilled', 'rejected']

Maggiori informazioni nel post sul blog v8 https://v8.dev/features/promise-combinators

Come ha detto @jib,

Promise.all è tutto o niente.

Tuttavia, puoi controllare alcune promesse che sono "autorizzate" a fallire e vorremmo procedere .then.

Per esempio.

  Promise.all([
    doMustAsyncTask1,
    doMustAsyncTask2,
    doOptionalAsyncTask
    .catch(err => {
      if( /* err non-critical */) {
        return
      }
      // if critical then fail
      throw err
    })
  ])
  .then(([ mustRes1, mustRes2, optionalRes ]) => {
    // proceed to work with results
  })

se riesci ad usare la libreria q https://github.com/kriskowal/q ha il metodo q.allSettled () in grado di risolvere questo problema, puoi gestire ogni promessa a seconda del suo stato o compilato o rifiutato così

existingPromiseChain = existingPromiseChain.then(function() {
var arrayOfPromises = state.routes.map(function(route){
  return route.handler.promiseHandler();
});
return q.allSettled(arrayOfPromises)
});

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
//so here you have all your promises the fulfilled and the rejected ones
// you can check the state of each promise
arrayResolved.forEach(function(item){
   if(item.state === 'fulfilled'){ // 'rejected' for rejected promises
     //do somthing
   } else {
     // do something else
   }
})
// do stuff with my array of resolved promises, eventually ending with a res.send();
});

Utilizzando Async await -

qui una funzione asincrona func1 sta restituendo un valore risolto, e func2 sta generando un errore e restituendo un valore nullo in questa situazione, possiamo gestirlo come vogliamo e restituire di conseguenza.

const callingFunction  = async () => {
    const manyPromises = await Promise.all([func1(), func2()]);
    console.log(manyPromises);
}


const func1 = async () => {
    return 'func1'
}

const func2 = async () => {
    try {
        let x;
        if (!x) throw "x value not present"
    } catch(err) {
       return null
    }
}

callingFunction();

L'output è - ['func1', null]

Per quelli che usano ES8 che inciampano qui, puoi fare qualcosa di simile al seguente, usando le funzioni asincrone :

var arrayOfPromises = state.routes.map(async function(route){
  try {
    return await route.handler.promiseHandler();
  } catch(e) {
    // Do something to handle the error.
    // Errored promises will return whatever you return here (undefined if you don't return anything).
  }
});

var resolvedPromises = await Promise.all(arrayOfPromises);

Siamo in grado di gestire il rifiuto a livello di singole promesse, quindi quando otteniamo i risultati nella nostra matrice dei risultati, sarà l'indice della matrice che è stato rifiutato undefined. Siamo in grado di gestire la situazione in base alle esigenze e utilizzare i risultati rimanenti.

Qui ho rifiutato la prima promessa, quindi viene definita indefinita, ma possiamo usare il risultato della seconda promessa, che è all'indice 1.

const manyPromises = Promise.all([func1(), func2()]).then(result => {
    console.log(result[0]);  // undefined
    console.log(result[1]);  // func2
});

function func1() {
    return new Promise( (res, rej) => rej('func1')).catch(err => {
        console.log('error handled', err);
    });
}

function func2() {
    return new Promise( (res, rej) => setTimeout(() => res('func2'), 500) );
}

Hai preso in considerazione Promise.prototype.finally()?

Sembra essere progettato per fare esattamente quello che vuoi: eseguire una funzione una volta che tutte le promesse sono state stabilite (risolte / rifiutate), indipendentemente dal fatto che alcune promesse vengano respinte.

Dalla documentazione MDN :

Il finally()metodo può essere utile se si desidera eseguire l'elaborazione o la pulizia una volta stabilita la promessa, indipendentemente dal risultato.

Il finally()metodo è molto simile alla chiamata, .then(onFinally, onFinally)tuttavia ci sono un paio di differenze:

Quando si crea una funzione in linea, è possibile passarla una volta, anziché essere costretta a dichiararla due volte o creare una variabile per essa.

Un callback infine non riceverà alcun argomento, poiché non esiste alcun mezzo affidabile per determinare se la promessa è stata rispettata o respinta. Questo caso d'uso è proprio quando non ti interessa il motivo del rifiuto, o il valore di adempimento, e quindi non è necessario fornirlo.

Diversamente Promise.resolve(2).then(() => {}, () => {})(che verrà risolto con undefined), Promise.resolve(2).finally(() => {})verrà risolto con 2. Allo stesso modo, diversamente Promise.reject(3).then(() => {}, () => {})(che verrà risolto con undefined), Promise.reject(3).finally(() => {})verrà rifiutato con 3.

== Fallback ==

Se la tua versione di JavaScript non supporta Promise.prototype.finally()è possibile utilizzare questa soluzione alternativa da Jake Archibald :Promise.all(promises.map(p => p.catch(() => undefined)));

In alternativa, se hai un caso in cui non ti preoccupi particolarmente dei valori delle promesse risolte quando si verifica un errore ma vuoi comunque che vengano eseguite, potresti fare qualcosa del genere che risolverà con le promesse normalmente quando tutti riescono e rifiutano con le promesse fallite quando qualcuno di loro fallisce:

function promiseNoReallyAll (promises) {
  return new Promise(
    async (resolve, reject) => {
      const failedPromises = []

      const successfulPromises = await Promise.all(
        promises.map(
          promise => promise.catch(error => {
            failedPromises.push(error)
          })
        )
      )

      if (failedPromises.length) {
        reject(failedPromises)
      } else {
        resolve(successfulPromises)
      }
    }
  )
}

Puoi sempre racchiudere le tue funzioni di restituzione della promessa in modo tale da rilevare l'errore e restituire invece un valore concordato (ad es. Messaggio di errore), in modo che l'eccezione non si estenda fino alla funzione Promessa.all e la disabiliti.

async function resetCache(ip) {

    try {

        const response = await axios.get(`http://${ip}/resetcache`);
        return response;

    }catch (e) {

        return {status: 'failure', reason: 'e.message'};
    }

}

Ho trovato un modo (soluzione alternativa) per farlo senza farlo sincronizzare.

Quindi, come è stato menzionato prima Promise.all è tutto.

quindi ... Usa una promessa acclusa per catturare e forzare la risoluzione.

      let safePromises = originalPrmises.map((imageObject) => {
            return new Promise((resolve) => {
              // Do something error friendly
              promise.then(_res => resolve(res)).catch(_err => resolve(err))
            })
        })
    })

    // safe
    return Promise.all(safePromises)

Dovresti sapere come identificare un errore nei risultati. Se non si verifica un errore previsto standard, è consigliabile eseguire una trasformazione su ciascun errore nel blocco catch che lo rende identificabile nei risultati.

try {
  let resArray = await Promise.all(
    state.routes.map(route => route.handler.promiseHandler().catch(e => e))
  );

  // in catch(e => e) you can transform your error to a type or object
  // that makes it easier for you to identify whats an error in resArray
  // e.g. if you expect your err objects to have e.type, you can filter
  // all errors in the array eg
  // let errResponse = resArray.filter(d => d && d.type === '<expected type>')
  // let notNullResponse = resArray.filter(d => d)

  } catch (err) {
    // code related errors
  }

Non è il modo migliore per registrare gli errori, ma è sempre possibile impostare tutto su un array per promiseAll e archiviare i risultati risultanti in nuove variabili.

Se usi graphQL devi postelaborare la risposta a prescindere e se non trova il riferimento corretto, bloccherà l'app, restringendo dove si trova il problema

const results = await Promise.all([
  this.props.client.query({
    query: GET_SPECIAL_DATES,
  }),
  this.props.client.query({
    query: GET_SPECIAL_DATE_TYPES,
  }),
  this.props.client.query({
    query: GET_ORDER_DATES,
  }),
]).catch(e=>console.log(e,"error"));
const specialDates = results[0].data.specialDates;
const specialDateTypes = results[1].data.specialDateTypes;
const orderDates = results[2].data.orders;

Ecco come Promise.allè progettato per funzionare. Se una sola promessareject() è, l'intero metodo fallisce immediatamente.

Ci sono casi d'uso in cui si potrebbe desiderare che le Promise.allpromesse vengano meno. Per far sì che ciò accada, semplicemente non usare alcuna reject()dichiarazione nella tua promessa. Tuttavia, per assicurarti che la tua app / script non si blocchi nel caso in cui una singola promessa sottostante non ottenga mai una risposta, devi mettere un timeout su di essa.

function getThing(uid,branch){
    return new Promise(function (resolve, reject) {
        xhr.get().then(function(res) {
            if (res) {
                resolve(res);
            } 
            else {
                resolve(null);
            }
            setTimeout(function(){reject('timeout')},10000)
        }).catch(function(error) {
            resolve(null);
        });
    });
}

Ho scritto una libreria npm per affrontare questo problema in modo più bello. https://github.com/wenshin/promiseallend

Installare

npm i --save promiseallend

25/02/2017 nuova api, non rompere i principi della promessa

const promiseAllEnd = require('promiseallend');

const promises = [Promise.resolve(1), Promise.reject('error'), Promise.resolve(2)];
const promisesObj = {k1: Promise.resolve(1), k2: Promise.reject('error'), k3: Promise.resolve(2)};

// input promises with array
promiseAllEnd(promises, {
    unhandledRejection(error, index) {
        // error is the original error which is 'error'.
        // index is the index of array, it's a number.
        console.log(error, index);
    }
})
    // will call, data is `[1, undefined, 2]`
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

// input promises with object
promiseAllEnd(promisesObj, {
    unhandledRejection(error, prop) {
        // error is the original error.
        // key is the property of object.
        console.log(error, prop);
    }
})
    // will call, data is `{k1: 1, k3: 2}`
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

// the same to `Promise.all`
promiseAllEnd(promises, {requireConfig: true})
    // will call, `error.detail` is 'error', `error.key` is number 1.
    .catch(error => console.log(error.detail))

// requireConfig is Array
promiseAllEnd(promises, {requireConfig: [false, true, false]})
    // won't call
    .then(data => console.log(data))
    // will call, `error.detail` is 'error', `error.key` is number 1.
    .catch(error => console.log(error.detail))

// requireConfig is Array
promiseAllEnd(promises, {requireConfig: [true, false, false]})
    // will call, data is `[1, undefined, 2]`.
    .then(data => console.log(data))
    // won't call
    .catch(error => console.log(error.detail))

--------------------------------

Vecchia cattiva API, non usarla!

let promiseAllEnd = require('promiseallend');

// input promises with array
promiseAllEnd([Promise.resolve(1), Promise.reject('error'), Promise.resolve(2)])
    .then(data => console.log(data)) // [1, undefined, 2]
    .catch(error => console.log(error.errorsByKey)) // {1: 'error'}

// input promises with object
promiseAllEnd({k1: Promise.resolve(1), k2: Promise.reject('error'), k3: Promise.resolve(2)})
    .then(data => console.log(data)) // {k1: 1, k3: 2}
    .catch(error => console.log(error.errorsByKey)) // {k2: 'error'}