Brechen javascript Versprechen Kette in eine saubere Art und Weise

Ich versuche, mich an die Kette verspricht, so dass die Kette unterbrochen werden, wenn ein Versprechen ist abgelehnt. Ich folgte die Leitungen eines Vorherige Frage ALSO und versucht, es anzuwenden, um native Versprechen, aber ich denke, ich bin Missverständnis, wie die Dinge funktionieren.

Hier ist, wie ich geschrieben haben den code:

Promise.resolve()
    .then(function() {
        return step(1)
            .then(null, function() {
                stepError(1);
            });
    })
    .then(function() {
        return step(2)
            .then(null, function() {
                stepError(2);
            });
    })
    .then(function() {
        return step(3)
            .then(null, function() {
                stepError(3);
            });
    });

function step(n) {
    console.log('Step '+n);
    return (n === 2) ? Promise.reject(n) : Promise.resolve(n);
}

function stepError(n) {
    console.log('Error '+n);
    return Promise.reject(n);
}

Die Ausgabe des obigen code ist:

Step 1
Step 2
Error 2
Step 3
[UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): 2]

In meinem Verständnis, Schritt 2 sollte die Kette durchbrechen und Schritt 3 nicht ausgeführt werden soll. Wenn Schritt(2) gibt eine abgelehnt Versprechen, stepError(2) wird ausgeführt, wie erwartet. Aber da gibt es Versprechen.lehnen(2), die Funktion in der nächsten dann nicht ausgeführt werden soll, und da gibt es nicht zu fangen, die in dem Ende, die abgelehnt Versprechen von Schritt 2 scheint wie erwartet weitergeleitet werden, bis es beendet die Kette, weil Sie nicht finden, eine handler.

Was vermisse ich hier ?

Hier ein JSFiddle, um mit zu spielen: https://jsfiddle.net/6p4t9xyk/

InformationsquelleAutor user6822275 | 2016-12-11

javascript promise

In meinem Verständnis, sollte Schritt 2 brechen Sie die Kette...

Es würde, aber du hast versehentlich umgestellt, dass die Ablehnung in eine Auflösung.

Das wichtigste Versprechen ist, dass jeder Aufruf then schafft eine neue Versprechen das behoben ist/abgelehnt basierend auf dem, was die then callback(s) zu tun, und die callback-Verarbeitung eine Ablehnung wandelt, dass die Ablehnung in eine Auflösung, es sei denn, es absichtlich tut, sonst.

Also hier:

return step(2)
    .then(null, function() {  //This handler converts the
        stepError(2);         //rejection into a resolution
    });                       //with the value `undefined`

Ist das so, dass man Fehler Handler als Ausgleich für den Fehler.

Seit stepError gibt eine Ablehnung, Sie können weiterhin die Ablehnung, indem Sie nur eine return:

return step(2)
    .then(null, function() {
        return stepError(2);  //Added `return`
    });

...oder alternativ, entfernen Sie das hf ganz:

return step(2);

...oder man könnte throw im callback verwendet werden, welche automatisch verwandelte sich in Ablehnung.

Die unbehandelte Ablehnungsandrohung ist durch die Tatsache verursacht, nichts braucht die Ablehnung von stepError.

Hier ein Beispiel gibt das Ergebnis der stepError:

JS:

Promise.resolve()
    .then(function() {
        return step(1)
            .then(null, function() {
                return stepError(1); //Added `return`
            });
    })
    .then(function() {
        return step(2)
            .then(null, function() {
                return stepError(2); //Added `return`
            });
    })
    .then(function() {
        return step(3)
            .then(null, function() {
                return stepError(3); //Added `return`
            });
    });

function step(n) {
    console.log('Step '+n);
    return (n === 2) ? Promise.reject(n) : Promise.resolve(n);
}

function stepError(n) {
    console.log('Error '+n);
    return Promise.reject(n);
}

InformationsquelleAutor T.J. Crowder

Sieht aus wie Sie kompliziert ist es ganz ein wenig. Wie wäre es mit:

JS:

function step(n) {
    console.log('Step '+n);
    return (n === 2) ? Promise.reject(n) : Promise.resolve(n);
}

function stepError(n) {
    console.log('Error '+n);
}

Promise.resolve()
    .then(() => step(1))
    .then(() => step(2))
    .then(() => step(3)) //never here
    .catch(stepError);

In der Regel", dann eingerückt" ist ein antipattern. Alle "thens" sollte auf der gleichen Ebene.

Danke für die Antwort. Ich upvote, aber es fehlt ein wenig der Erklärung. Danke für die Mühe aber !

InformationsquelleAutor georg

Als @T. J. Crowder sagte, Sie vergaß zu return das Ergebnis der Fehler-handler (oder zu throw aus). Um es zu reparieren, ich würde empfehlen, tun entweder

function withStepError(n, promise) {
    return promise.catch(function(err) {
        console.log('Error '+err+' from '+n);
        throw new Error("failed at "+n);
    });
}
Promise.resolve()
.then(function() {
    return withStepError(1, step(1));
})
.then(function() {
    return withStepError(2, step(2));
})
.then(function() {
    return withStepError(3, step(3));
});

oder

function getStepError(n) {
    return function(err) {
        console.log('Error '+err+' from '+n);
        throw new Error("failed at "+n);
    };
}

Promise.resolve()
.then(function() {
    return step(1).catch(getStepError(1));
})
.then(function() {
    return step(2).catch(getStepError(2));
})
.then(function() {
    return step(3).catch(getStepError(3));
});

InformationsquelleAutor Bergi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.