Warten Sie, bis alle ES6 promises komplett, sogar abgelehnt verspricht

Benjamins Antwort bietet eine große Abstraktion für die Lösung dieses Problems, aber ich hatte gehofft, für eine weniger abstrahierte Lösung. Der explizite Weg, um dieses Problem zu beheben ist, rufen Sie einfach .catch auf der internen verspricht, und wieder den Fehler, von Ihren Rückruf.

let a = new Promise((res, rej) => res('Resolved!')),
    b = new Promise((res, rej) => rej('Rejected!')),
    c = a.catch(e => { console.log('"a" failed.'); return e; }),
    d = b.catch(e => { console.log('"b" failed.'); return e; });

Promise.all([c, d])
  .then(result => console.log('Then', result)) //Then ["Resolved!", "Rejected!"]
  .catch(err => console.log('Catch', err));

Promise.all([a.catch(e => e), b.catch(e => e)])
  .then(result => console.log('Then', result)) //Then ["Resolved!", "Rejected!"]
  .catch(err => console.log('Catch', err));

Einnahme dieses einen Schritt weiter, könnten Sie schreiben eine generische catch-handler, der wie folgt aussieht:

const catchHandler = error => ({ payload: error, resolved: false });

dann können Sie

> Promise.all([a, b].map(promise => promise.catch(catchHandler))
    .then(results => console.log(results))
    .catch(() => console.log('Promise.all failed'))
< [ 'Resolved!',  { payload: Promise, resolved: false } ]

Das problem mit diesem ist, dass die Gefangenen-Werte wird eine andere Schnittstelle als die nicht-gefangen-Werte, so reinigen Sie diesen, bis Sie vielleicht so etwas machen:

const successHandler = result => ({ payload: result, resolved: true });

So, jetzt können Sie dies tun:

> Promise.all([a, b].map(result => result.then(successHandler).catch(catchHandler))
    .then(results => console.log(results.filter(result => result.resolved))
    .catch(() => console.log('Promise.all failed'))
< [ 'Resolved!' ]

Dann TROCKEN zu halten, bekommen Sie auf Benjamins Antwort:

const reflect = promise => promise
  .then(successHandler)
  .catch(catchHander)

wo es jetzt aussieht wie

> Promise.all([a, b].map(result => result.then(successHandler).catch(catchHandler))
    .then(results => console.log(results.filter(result => result.resolved))
    .catch(() => console.log('Promise.all failed'))
< [ 'Resolved!' ]

Die Vorteile des zweiten Ansatzes liegen in seiner abstrahierten und TROCKEN. Der Nachteil ist, Sie haben mehr code, und Sie haben sich daran zu erinnern zu reflektieren, die alle Ihre Versprechungen zu machen, die Dinge konsistent.

Ich würde charakterisieren meine Lösung als explizite und KÜSSEN, aber in der Tat weniger robust. Nicht in der Schnittstelle garantieren, dass Sie genau wissen, ob die Versprechen, erfolgreich oder fehlgeschlagen.

Zum Beispiel könnten Sie haben:

const a = Promise.resolve(new Error('Not beaking, just bad'));
const b = Promise.reject(new Error('This actually didnt work'));

Diese nicht verfangen a.catch, so

> Promise.all([a, b].map(promise => promise.catch(e => e))
    .then(results => console.log(results))
< [ Error, Error ]

Gibt es keine Möglichkeit zu sagen, was man war tödlich und das war nicht war. Wenn das wichtig ist, dann sind Sie gehen zu wollen, um die Durchsetzung und die Schnittstelle, die verfolgt, ob es erfolgreich war oder nicht (was reflect tut).

Wenn Sie nur wollen, um Fehler zu behandeln anmutig, dann können Sie so behandeln Sie Fehlermeldungen wie " undefined Werte:

> Promise.all([a.catch(() => undefined), b.catch(() => undefined)])
    .then((results) => console.log('Known values: ', results.filter(x => typeof x !== 'undefined')))
< [ 'Resolved!' ]

In meinem Fall, brauche ich nicht zu wissen, die Fehler oder wie man es fehlgeschlagen ist-ich habe nur Sorge, ob ich das Wert ist oder nicht. Ich lasse die Funktion generiert das Versprechen sorgen um die Protokollierung der jeweiligen Fehler.

const apiMethod = () => fetch()
  .catch(error => {
    console.log(error.message);
    throw error;
  });

So, der rest der Anwendung können Sie ignorieren die Fehler, wenn es will, und behandeln es als einen undefinierten Wert, wenn es will.

Möchte ich mein high-level-Funktionen fehlschlagen, sicher und sich keine sorgen über die details, warum der Abhängigkeiten ist fehlgeschlagen, und ich habe auch lieber KÜSSEN, um zu TROCKNEN, wenn ich nach stellen, die Kompromiss-das ist letztlich der Grund, warum ich entschieden nicht zu verwenden reflect.

InformationsquelleAutor Nathan Hagen

var err;
Promise.all([
    promiseOne().catch(function(error) { err = error;}),
    promiseTwo().catch(function(error) { err = error;})
]).then(function() {
    if (err) {
        throw err;
    }
});

Den Promise.all schlucken alle abgelehnt Versprechen und zu speichern, die Fehlermeldung in eine variable, so wird es wiederkommen, wenn all die Versprechungen aufgelöst haben. Dann können Sie erneut auslösen, den Fehler aus, oder tun, was auch immer. Auf diese Weise, ich denke, Sie würde bekommen, die letzten Ablehnung statt der ersten.

InformationsquelleAutor martin770

Diese sollte im Einklang mit wie F es tut:

if(!Promise.allSettled) {
    Promise.allSettled = function (promises) {
        return Promise.all(promises.map(p => Promise.resolve(p).then(v => ({
            state: 'fulfilled',
            value: v,
        }), r => ({
            state: 'rejected',
            reason: r,
        }))));
    };
}

InformationsquelleAutor mpen

Hier mein custom settledPromiseAll()

const settledPromiseAll = function(promisesArray) {
  var savedError;

  const saveFirstError = function(error) {
    if (!savedError) savedError = error;
  };
  const handleErrors = function(value) {
    return Promise.resolve(value).catch(saveFirstError);
  };
  const allSettled = Promise.all(promisesArray.map(handleErrors));

  return allSettled.then(function(resolvedPromises) {
    if (savedError) throw savedError;
    return resolvedPromises;
  });
};

Im Vergleich zu Promise.all

• Wenn alle zusagen sind behoben, es führt genau so, wie der standard.

• Wenn man mehr verspricht, werden abgelehnt, es gibt die erste abgelehnt, viel die gleiche wie die standard, aber anders als er wartet, bis alle Versprechungen zu beheben/ablehnen.

Für die mutigen könnten wir ändern Promise.all():

(function() {
  var stdAll = Promise.all;

  Promise.all = function(values, wait) {
    if(!wait)
      return stdAll.call(Promise, values);

    return settledPromiseAll(values);
  }
})();

VORSICHTIG. In der Regel können wir nie ändern, built-ins, da es brechen könnte andere, nicht Verwandte JS-Bibliotheken oder die Auseinandersetzung mit zukünftigen Veränderungen zu JS-standards.

Meine settledPromiseall ist rückwärts kompatibel mit Promise.all und erweitert seine Funktionalität.

Menschen, die Entwicklung von standards-warum nicht diese auf ein neues Versprechen-standard?

InformationsquelleAutor Edward

Ich tun würde:

var err = [fetch('index.html').then((success) => { return Promise.resolve(success); }).catch((e) => { return Promise.resolve(e); }),
fetch('http://does-not-exist').then((success) => { return Promise.resolve(success); }).catch((e) => { return Promise.resolve(e); })];

Promise.all(err)
.then(function (res) { console.log('success', res) })
.catch(function (err) { console.log('error', err) }) //never executed

InformationsquelleAutor FRocha

Ich weiß, dass diese Frage hat viele Antworten, und ich bin sicher, muss (wenn nicht alle) sind richtig.
Allerdings war es sehr schwer für mich zu verstehen, die Logik - /Fluss dieser Antworten.

Also habe ich mir die Original-Implementierung auf Promise.all(), und ich versuchte, Sie zu imitieren, dass Logik - mit Ausnahme der nicht zu stoppen die Ausführung, wenn ein Versprechen gescheitert.

  public promiseExecuteAll(promisesList: Promise<any>[] = []): Promise<{ data: any, isSuccess: boolean }[]>
  {
    let promise: Promise<{ data: any, isSuccess: boolean }[]>;

    if (promisesList.length)
    {
      const result: { data: any, isSuccess: boolean }[] = [];
      let count: number = 0;

      promise = new Promise<{ data: any, isSuccess: boolean }[]>((resolve, reject) =>
      {
        promisesList.forEach((currentPromise: Promise<any>, index: number) =>
        {
          currentPromise.then(
            (data) => //Success
            {
              result[index] = { data, isSuccess: true };
              if (promisesList.length <= ++count) { resolve(result); }
            },
            (data) => //Error
            {
              result[index] = { data, isSuccess: false };
              if (promisesList.length <= ++count) { resolve(result); }
            });
        });
      });
    }
    else
    {
      promise = Promise.resolve([]);
    }

    return promise;
  }

Erklärung:

- Schleife über die Eingabe promisesList und führen Sie die einzelnen Versprechen.

- Egal, ob das Versprechen gelöst oder abgelehnt: speichern Sie das Versprechen, das Ergebnis in eine result array nach der index. Speichern Sie auch die resolve/ablehnen-status (isSuccess).

- Wenn alle Versprechen abgeschlossen, kehren Sie ein Versprechen mit dem Ergebnis aller anderen.

Beispiel verwenden:

const p1 = Promise.resolve("OK");
const p2 = Promise.reject(new Error(":-("));
const p3 = Promise.resolve(1000);

promiseExecuteAll([p1, p2, p3]).then((data) => {
  data.forEach(value => console.log(`${ value.isSuccess ? 'Resolve' : 'Reject' } >> ${ value.data }`));
});

/* Output: 
Resolve >> OK
Reject >> :-(
Resolve >> 1000
*/

InformationsquelleAutor Gil Epshtain