JavaScript-Versprechen - Ablehnung vs.

Habe ich gelesen, mehrere Artikel zu diesem Thema, aber es ist immer noch nicht klar ist mir, ob es einen Unterschied zwischen Promise.reject vs. werfen einen Fehler. Zum Beispiel,

Mit Versprechen.ablehnen

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            return Promise.reject(new PermissionDenied());
        }
    });

Mit werfen

return asyncIsPermitted()
    .then(function(result) {
        if (result === true) {
            return true;
        }
        else {
            throw new PermissionDenied();
        }
    });

Meine Vorliebe ist die Verwendung throw einfach, weil es kürzer ist, aber Frage mich, ob es keinen Vorteil des einen über den anderen.

Kommentar zu dem Problem
Beide Methoden erzeugen die exakt gleiche Reaktion. Die .dann ist() - handler fängt die geworfene Ausnahme und verwandelt es in eine abgelehnt Versprechen automatisch. Da ich gelesen habe, dass Ausnahmen ausgelöst werden, nicht besonders schnell ausführen, würde ich vermuten, dass eine Rücksendung der beanstandeten Versprechen könnten etwas schneller ausgeführt werden, aber Sie würde zu entwickeln, einen test in mehreren modernen Browsern, wenn das wichtig zu wissen. Ich persönlich nutze werfen, weil ich gerne die Lesbarkeit. Kommentarautor: jfriend00
@webduvet nicht mit Versprechungen - Sie sind entworfen, um mit zu werfen. Kommentarautor: joews
Ein Nachteil werfen ist, dass es nicht Folge eines abgelehnten Versprechen, wenn er ausgelöst wurde, innerhalb von ein asynchroner Rückruf, wie ein setTimeout. jsfiddle.net/m07van33 @Blondie Ihre Antwort richtig war. Kommentarautor: Kevin B
@joews es bedeutet nicht, dass es gut ist 😉 Kommentarautor: webduvet
Ah, stimmt. So eine Klarstellung zu meinem Kommentar wäre, "wenn er ausgelöst wurde, von einer asynchronen callback - das war nicht promisified". Ich wusste, es war eine Ausnahme, ich konnte mich einfach nicht erinnern, was es war. Auch ich bevorzuge werfen, einfach weil ich finde, es ist besser lesbar und ermöglicht es mir, ohne ablehnen es von meinem param-Liste. Kommentarautor: Kevin B

InformationsquelleAutor der Frage Naresh | 2015-10-30

  1. 30

    Ja, der größte Unterschied ist, dass ablehnen ist eine callback-Funktion, die wird durchgeführt nach dem Versprechen abgelehnt wird, in der Erwägung, dass werfen kann nicht verwendet werden, asynchron ausgeführt werden. Wenn Sie ablehnen, wird Ihr code wird weiterhin ausgeführt, die normalerweise im asynchronen Mode in der Erwägung, dass werfen wird priorisieren Abschluss der resolver-Funktion (diese Funktion wird sofort ausgeführt).

    Beispiel habe ich gesehen, das geholfen hat, klären die Frage für mich war, dass Sie eine Timeout-Funktion, mit lehnen, zum Beispiel:

    new Promise(_, reject) {
 setTimeout(reject, 3000);
});

    Oben könnte nicht möglich sein würde zu schreiben, mit werfen.

    In deinem kleinen Beispiel den Unterschied nicht zu unterscheiden, aber beim Umgang mit komplexeren asynchronen Konzept der Unterschied zwischen den beiden können drastisch sein.

    InformationsquelleAutor der Antwort Blondie

  2. 17

    TLDR: EINE Funktion ist schwer zu verwenden, wenn es auch mal wieder ein Versprechen und manchmal wirft eine Ausnahme. Beim schreiben einer asynchronen Funktion, lieber signalstörung durch Rücksendung einer abgelehnten Versprechen

    Ihre besonderen Beispiel verbirgt einige wichtige Unterschiede zwischen Ihnen:

    Weil Sie die Fehlerbehandlung innen ein Versprechen Kette, die geworfenen exceptions werden automatisch umgewandelt abgelehnt verspricht. Dies mag erklären, warum Sie zu sein scheinen austauschbar sind - Sie sind es nicht.

    Betrachten die situation unten:

    checkCredentials = () => {
    let idToken = localStorage.getItem('some token');
    if ( idToken ) {
      return fetch(`https://someValidateEndpoint`, {
        headers: {
          Authorization: `Bearer ${idToken}`
        }
      })
    } else {
      throw new Error('No Token Found In Local Storage')
    }
  }

    Dies wäre ein anti-pattern, da würden Sie dann brauchen, um unterstützen sowohl die async-und sync-Fehlern. Es könnte so Aussehen:

    try {
  function onFulfilled() { ... do the rest of your logic }
  function onRejected() { //handle async failure - like network timeout }
  checkCredentials(x).then(onFulfilled, onRejected);
} catch (e) {
  //Error('No Token Found In Local Storage')
  //handle synchronous failure
}

    Nicht gut und hier ist, wo genau Promise.reject ( im globalen scope verfügbar ) kommt zur Rettung und effektiv unterscheidet sich von throw. Die Umgestaltung wird jetzt:

    checkCredentials = () => {
  let idToken = localStorage.getItem('some_token');
  if (!idToken) {
    return Promise.reject('No Token Found In Local Storage')
  }
  return fetch(`https://someValidateEndpoint`, {
    headers: {
      Authorization: `Bearer ${idToken}`
    }
  })
}

    Diese können Sie jetzt mit nur einer catch() für Netzwerk-Ausfälle und die synchrone Fehler-check für fehlende Token:

    checkCredentials()
      .catch((error) => if ( error == 'No Token' ) {
      //do no token modal
      } else if ( error === 400 ) {
      //do not authorized modal. etc.
      }

    InformationsquelleAutor der Antwort maxwell

Schreibe einen Kommentar