Fehlerbehandlung in Promise.all

Ich habe eine Reihe von Versprechungen, mit denen ich löse Promise.all(arrayOfPromises);

Ich setze die Versprechen-Kette fort. Sieht ungefähr so ​​aus

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();
});

Ich möchte eine catch-Anweisung hinzufügen, um ein einzelnes Versprechen zu behandeln, falls es fehlerhaft ist. Wenn ich es jedoch versuche, wird Promise.allder erste gefundene Fehler zurückgegeben (der Rest wird ignoriert), und dann kann ich die Daten aus dem Rest der Versprechen in nicht abrufen das Array (das hat keinen Fehler gemacht).

Ich habe versucht, so etwas wie ..

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();
});

Das lässt sich aber nicht lösen.

Vielen Dank!

- -

Bearbeiten:

Was die folgenden Antworten sagten, war völlig richtig, der Code brach aus anderen Gründen. Falls jemand interessiert ist, ist dies die Lösung, die ich gefunden habe ...

Node Express-Serverkette

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;
            })
    };

API-Aufruf (route.async-Aufruf)

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

Das Setzen des .catchfor Promise.allvor das .thenscheint den Zweck erfüllt zu haben, Fehler aus den ursprünglichen Versprechungen abzufangen, aber dann das gesamte Array zum nächsten zurückzukehren.then

Vielen Dank!

Promise.allist alles oder nichts. Es wird aufgelöst, sobald alle Versprechen im Array aufgelöst wurden, oder abgelehnt, sobald einer von ihnen ablehnt. Mit anderen Worten, es wird entweder mit einem Array aller aufgelösten Werte aufgelöst oder mit einem einzigen Fehler zurückgewiesen.

Einige Bibliotheken haben einen Namen Promise.when, von dem ich verstehe, dass er stattdessen darauf wartet, dass alle Versprechen im Array entweder aufgelöst oder abgelehnt werden, aber ich bin nicht damit vertraut und es ist nicht in ES6.

Dein Code

Ich stimme anderen hier zu, dass Ihr Fix funktionieren sollte. Es sollte mit einem Array aufgelöst werden, das eine Mischung aus erfolgreichen Werten und Fehlerobjekten enthalten kann. Es ist ungewöhnlich, Fehlerobjekte im Erfolgspfad zu übergeben, aber wenn Ihr Code sie erwartet, sehe ich kein Problem damit.

Der einzige Grund, warum ich mir vorstellen kann, warum es "nicht aufgelöst" werden kann, ist, dass der Code, den Sie uns nicht anzeigen, fehlschlägt und dass Sie keine Fehlermeldung dazu sehen, weil diese Versprechenskette nicht mit einem Finale beendet wird fangen (soweit du uns sowieso zeigst).

Ich habe mir die Freiheit genommen, die "vorhandene Kette" aus Ihrem Beispiel herauszurechnen und die Kette mit einem Haken zu beenden. Dies mag für Sie nicht richtig sein, aber für Leute, die dies lesen, ist es wichtig, immer entweder Ketten zurückzugeben oder zu beenden, da sonst potenzielle Fehler, sogar Codierungsfehler, versteckt werden (was meiner Meinung nach hier passiert ist):

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
});

NEUE ANTWORT

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

FUTURE Promise API

• Chrome 76: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
• Sie können https://www.npmjs.com/package/promise.allsettled herunterladen , um es jetzt zu erhalten. In bestimmten Browsern ist allSettled mit dem Browser selbst vorinstalliert. Es lohnt sich, das Paket zur Beruhigung herunterzuladen, da z. TypeScript hat keine Standarddefinitionen für allSettled.

Um die Promise.allSchleife fortzusetzen (auch wenn ein Versprechen abgelehnt wird), habe ich eine Dienstprogrammfunktion geschrieben, die aufgerufen wird executeAllPromises. Diese Dienstprogrammfunktion gibt ein Objekt mit resultsund zurück errors.

Die Idee ist, dass alle Versprechen, an die Sie weitergeben, executeAllPromisesin ein neues Versprechen verpackt werden, das immer aufgelöst wird. Das neue Versprechen wird mit einem Array mit 2 Punkten aufgelöst. Der erste Punkt enthält den Auflösungswert (falls vorhanden) und der zweite Punkt enthält den Fehler (wenn das verpackte Versprechen abgelehnt wird).

Als letzter Schritt werden executeAllPromisesalle Werte der verpackten Versprechen akkumuliert und das endgültige Objekt mit einem Array für resultsund einem Array für zurückgegeben errors.

Hier ist der Code:

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 führt eine neue Methode für den Promise-Typ ein: Promise.allSettled()
Promise.allSettled gibt Ihnen ein Signal, wenn alle Eingabeversprechen erfüllt sind, was bedeutet, dass sie entweder erfüllt oder abgelehnt werden. Dies ist nützlich, wenn Sie sich nicht für den Stand des Versprechens interessieren, sondern nur wissen möchten, wann die Arbeit erledigt ist, unabhängig davon, ob sie erfolgreich war.

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']

Lesen Sie mehr im v8-Blogbeitrag https://v8.dev/features/promise-combinators

Wie @jib sagte,

Promise.all ist alles oder nichts.

Sie können jedoch bestimmte Versprechen kontrollieren, die "scheitern" dürfen, und wir möchten fortfahren .then.

Beispielsweise.

  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
  })

Wenn Sie die q-Bibliothek https://github.com/kriskowal/q verwenden können, verfügt sie über die q.allSettled () -Methode, mit der dieses Problem gelöst werden kann. Sie können jedes Versprechen je nach Status entweder vollständig erfüllen oder ablehnen

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();
});

Mit Async warten -

Hier gibt eine asynchrone Funktion func1 einen aufgelösten Wert zurück, und func2 gibt einen Fehler aus und gibt in dieser Situation eine Null zurück. Wir können damit umgehen, wie wir wollen, und entsprechend zurückgeben.

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();

Ausgabe ist - ['func1', null]

Für diejenigen, die ES8 verwenden und hier stolpern, können Sie mit asynchronen Funktionen Folgendes tun :

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);

Wir können die Ablehnung auf der Ebene der einzelnen Versprechen behandeln. Wenn wir also die Ergebnisse in unserem Ergebnisarray erhalten, ist der abgelehnte Array-Index undefined. Wir können mit dieser Situation nach Bedarf umgehen und die verbleibenden Ergebnisse verwenden.

Hier habe ich das erste Versprechen abgelehnt, daher ist es undefiniert, aber wir können das Ergebnis des zweiten Versprechens verwenden, das sich auf Index 1 befindet.

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) );
}

Hast du darüber nachgedacht Promise.prototype.finally()?

Es scheint so konzipiert zu sein, dass es genau das tut, was Sie wollen - eine Funktion ausführen, sobald alle Versprechen erfüllt (gelöst / abgelehnt) sind, unabhängig davon, ob einige der Versprechen abgelehnt wurden.

Aus der MDN-Dokumentation :

Die finally()Methode kann nützlich sein, wenn Sie nach Erfüllung des Versprechens eine Verarbeitung oder Bereinigung durchführen möchten, unabhängig vom Ergebnis.

Die finally()Methode ist dem Aufruf sehr ähnlich, .then(onFinally, onFinally)es gibt jedoch einige Unterschiede:

Wenn Sie eine Funktion inline erstellen, können Sie sie einmal übergeben, anstatt gezwungen zu sein, sie entweder zweimal zu deklarieren oder eine Variable dafür zu erstellen.

Ein endgültiger Rückruf erhält kein Argument, da es kein zuverlässiges Mittel gibt, um festzustellen, ob das Versprechen erfüllt oder abgelehnt wurde. Dieser Anwendungsfall ist genau dann vorgesehen, wenn Sie sich nicht um den Ablehnungsgrund oder den Erfüllungswert kümmern und daher keine Angabe erforderlich ist.

Im Gegensatz Promise.resolve(2).then(() => {}, () => {})(was mit undefined aufgelöst wird) Promise.resolve(2).finally(() => {})wird mit 2 aufgelöst. Ebenso wird im Gegensatz zu Promise.reject(3).then(() => {}, () => {})(was mit undefined erfüllt wird) Promise.reject(3).finally(() => {})mit 3 abgelehnt.

== Fallback ==

Wenn Ihre JavaScript-Version dies nicht unterstützt Promise.prototype.finally(), können Sie diese Problemumgehung von Jake Archibald verwenden :Promise.all(promises.map(p => p.catch(() => undefined)));

Wenn Sie einen Fall haben, in dem Sie sich nicht besonders um die Werte der aufgelösten Versprechen kümmern, wenn es einen Fehler gibt, Sie aber dennoch möchten, dass sie ausgeführt werden, können Sie so etwas tun, das mit den Versprechen wie gewohnt gelöst wird, wenn Sie alle haben Erfolg und lehnen die fehlgeschlagenen Versprechen ab, wenn einer von ihnen versagt:

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)
      }
    }
  )
}

Sie können Ihre Versprechen-Rückgabefunktionen jederzeit so verpacken, dass sie Fehler auffangen und stattdessen einen vereinbarten Wert (z. B. error.message) zurückgeben, sodass die Ausnahme nicht bis zur Funktion Promise.all reicht und diese deaktiviert.

async function resetCache(ip) {

    try {

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

    }catch (e) {

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

}

Ich habe einen Weg gefunden (Problemumgehung), um dies zu tun, ohne es zu synchronisieren.

Wie bereits erwähnt, Promise.allist alles von keinem.

Also ... Verwenden Sie ein beiliegendes Versprechen, um die Entschlossenheit zu fangen und zu erzwingen.

      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)

Sie müssen wissen, wie Sie einen Fehler in Ihren Ergebnissen identifizieren können. Wenn Sie keinen erwarteten Standardfehler haben, schlage ich vor, dass Sie für jeden Fehler im catch-Block eine Transformation ausführen, die ihn in Ihren Ergebnissen identifizierbar macht.

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
  }

Nicht der beste Weg zum Fehlerprotokoll, aber Sie können immer alles auf ein Array für das VersprechenAll setzen und die resultierenden Ergebnisse in neuen Variablen speichern.

Wenn Sie graphQL verwenden, müssen Sie die Antwort unabhängig davon nachbearbeiten. Wenn die richtige Referenz nicht gefunden wird, stürzt die App ab und wird eingegrenzt, wo das Problem liegt

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;

So Promise.allsoll es funktionieren. Wenn ein einzelnes Versprechen reject()vorliegt, schlägt die gesamte Methode sofort fehl.

Es gibt Anwendungsfälle, in denen man möglicherweise zulassen möchte, Promise.alldass Versprechen scheitern. Verwenden Sie dazu einfach keine reject()Aussagen in Ihrem Versprechen. Um jedoch sicherzustellen, dass Ihre App / Ihr Skript nicht einfriert, falls ein einzelnes zugrunde liegendes Versprechen keine Antwort erhält, müssen Sie eine Zeitüberschreitung festlegen.

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);
        });
    });
}

Ich habe eine npm-Bibliothek geschrieben, um dieses Problem noch schöner zu lösen. https://github.com/wenshin/promiseallend

Installieren

npm i --save promiseallend

2017-02-25 neue API, es ist nicht Bruch Versprechen Prinzipien

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))

———————————————————————————————————

Alte schlechte API, benutze es nicht!

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'}