Umgang mit mehrfach-Fänge Versprechen Kette

Dieses Verhalten ist genau wie ein synchrones werfen:

try{
    throw new Error();
} catch(e){
    //handle
} 
//this code will run, since you recovered from the error!

Das ist die Hälfte der Punkt .catch - in der Lage sein sich zu erholen von Fehlern. Es könnte wünschenswert sein, um rethrow signal der Staat ist immer noch ein Fehler:

try{
    throw new Error();
} catch(e){
    //handle
    throw e; //or a wrapper over e so we know it wasn't handled
} 
//this code will not run

Aber das allein wird nicht funktionieren, in deinem Fall, da der Fehler abgefangen werden, durch einen später-handler. Das eigentliche Problem hier ist, dass generalisierte "NICHTS Anfassen" Fehler-Handler sind eine schlechte Praxis im Allgemeinen und sind extrem verpönt, in anderen Programmier-Sprachen und ökosysteme. Aus diesem Grund Bluebird bietet eingetippt und Prädikat Fänge.

Den zusätzlichen Vorteil, dass Sie Ihre business-Logik nicht (und sollte nicht) wissen, das request/response-Zyklus überhaupt. Es ist nicht die Abfrage in der Verantwortung zu entscheiden, welcher HTTP status-und Fehler-der Kunde bekommt und später, wie Ihre app wächst, möchten Sie vielleicht die Trennung der business-Logik (wie Abfrage von DB und Verarbeitung Ihrer Daten) von dem, was Sie an den client senden (was http-status-code, was text und was für eine Antwort).

Hier ist, wie ich den code schreiben.

Zuerst, ich würde zu bekommen .Query zu werfen NoSuchAccountError ich würde Unterklasse es aus Promise.OperationalError die Bluebird schon bietet. Wenn Sie unsicher sind, wie um eine Unterklasse ein Fehler lass es mich wissen.

Ich würde zusätzlich Unterklasse es für AuthenticationError tun, und dann etwas wie:

function changePassword(queryDataEtc){ 
    return repository.Query(getAccountByIdQuery)
                     .then(convertDocumentToModel)
                     .then(verifyOldPassword)
                     .then(changePassword);
}

Wie Sie sehen, es ist sehr sauber und man kann den text Lesen wie eine Bedienungsanleitung von dem, was passiert in den Prozess. Es ist auch getrennt von der Anfrage/Antwort.

Nun, würde ich es nennen, von der route-handler wie folgt:

 changePassword(params)
 .catch(NoSuchAccountError, function(e){
     res.status(404).send({ error: "No account found with this Id" });
 }).catch(AuthenticationError, function(e){
     res.status(406).send({ OldPassword: error });
 }).error(function(e){ //catches any remaining operational errors
     res.status(500).send({ error: "Unable to change password" });
 }).catch(function(e){
     res.status(500).send({ error: "Unknown internal server error" });
 });

Diese Weise die Logik ist alles an einem Ort und die Entscheidung, wie man Fehler behandelt, die für den Kunden alles an einem Ort, und Sie nicht in Unordnung zu trennen.

InformationsquelleAutor Benjamin Gruenbaum

Frage ich mich, ob es eine Möglichkeit gibt mir irgendwie Kraft, die Ketten zu stoppen, zu einem bestimmten Zeitpunkt, basierend auf die Fehler

Nicht. Sie können nicht wirklich "Ende" einer Kette, es sei denn, Sie werfen eine Ausnahme, die Blasen bis zu seinem Ende. Sehen Benjamin Gruenbaum Antwort für wie das zu tun.

Herleitung von seinem Muster wäre nicht zu unterscheiden, Fehler-Arten, jedoch nutzen, Fehler, die statusCode und body Felder, die gesendet werden können, von einem einzigen, generische .catch handler. Je nach Anwendung, Struktur, seine Lösung könnte sauberer sein aber.

oder ob es einen besseren Weg, um Struktur, um irgendeine form der Verzweigung Verhalten

Ja, Sie tun können,Verzweigung mit dem Versprechen. Dies bedeutet jedoch, lassen die Kette und "zurück" zu verschachteln - wie würde Sie in einer verschachtelten if-else oder try-catch-Anweisung:

repository.Query(getAccountByIdQuery)
.then(function(account) {
    return convertDocumentToModel(account)
    .then(verifyOldPassword)
    .then(function(verification) {
        return changePassword(verification)
        .then(function() {
            res.status(200).send();
        })
    }, function(verificationError) {
        res.status(406).send({ OldPassword: error });
    })
}, function(accountError){
    res.status(404).send({ error: "No account found with this Id" });
})
.catch(function(error){
    console.log(error);
    res.status(500).send({ error: "Unable to change password" });
});

InformationsquelleAutor Bergi

Statt .then().catch()... Sie tun können .then(resolveFunc, rejectFunc). Dieses Versprechen Kette wäre besser, wenn Sie behandelt Dinge auf dem Weg. Hier ist, wie würde ich umschreiben:

repository.Query(getAccountByIdQuery)
    .then(
        convertDocumentToModel,
        () => {
            res.status(404).send({ error: "No account found with this Id" });
            return Promise.reject(null)
        }
    )
    .then(
        verifyOldPassword,
        () => Promise.reject(null)
    )
    .then(
        changePassword,
        (error) => {
            if (error != null) {
                res.status(406).send({ OldPassword: error });
            }
            return Promise.Promise.reject(null);
        }
    )
    .then(
        _ => res.status(200).send(),
        error => {
            if (error != null) {
                console.error(error);
                res.status(500).send({ error: "Unable to change password" });
            }
        }
    );

Hinweis: Das if (error != null) ist ein bisschen ein hack, um die Interaktion mit den letzten Fehler.

InformationsquelleAutor mvndaai