如何捕获 ES6 Promise 拒绝并完全停止流程？

Question

假设我有 4 个函数：runA()、runB()、runC() 和 runD()。

使用 ES6 承诺，在完全成功的运行中，这些都将一个接一个地运行：

runA()
.then(runB)
.then(runC)
.then(runD)

如果runA 或runB 失败（拒绝或抛出），我想调用error1() 然后完全停止链（而不是调用runC 或runD）。这让我觉得我应该在.then 承诺链的最后添加一个.catch()：

runA()
.then(runB)
.then(runC)     //won't get called if runA or runB throws
.then(runD)     //won't get called if runA or runB throws
.catch(error1)

但如果runC 失败，我想调用error2() 并仍然停止链（而不是调用runD）。

runA()
.then(runB)   
.catch(error1)  //moved up to only handle runA and runB
.then(runC)     //but now this gets called after error1() is run
.then(runD)     
.catch(error2)

现在我在链中有 2 个 catch 调用，runC 将在 error1 运行后被调用，因为捕获的结果将默认为 resolve。让error1 函数创建一个它总是拒绝的承诺是我唯一的选择吗？

Answer 1

不，让error1 创建一个总是拒绝的承诺，不是你唯一的选择。

您可以利用.then 接受两个参数这一事实：

.then(onSuccess, onFailure)

当给定两个参数时，onFailure 将不会捕获onSuccess 中的故障，这一效果被低估了。这通常是不可取的，除了在这里，您可以使用这个事实来分支您的决策树：

runA()
.then(runB)
.then(() => runC().then(runD), error1)
.catch(error2)

这就是你想要的。

• 如果 runA 或 runB 失败，则调用 error1 并停止链。
• 如果 runC 或 runD 失败，则调用 error2 并停止链。

你也可以这样写：

runA()
.then(runB)
.then(() => runC()
  .then(runD)
  .catch(error2),
error1)

var log = msg => div.innerHTML += "<br>" + msg;

// Change which one of these four rejects, to see behavior:
var runA = () => Promise.resolve().then(() => log("a"));
var runB = () => Promise.reject().then(() => log("b"));
var runC = () => Promise.resolve().then(() => log("c"));
var runD = () => Promise.resolve().then(() => log("d"));
var error1 = () => log("error1");
var error2 = () => log("error2");

runA()
.then(runB)
.then(() => runC().then(runD), error1)
.catch(error2)

<div id="div"></div>

尝试修改this fiddle中哪个失败。

Answer 2

只使用一个.catch() 有什么问题？您可以在 catch 回调 (if (error1) error1() else if (error2) error2()...) 中进行错误分类。您抛出的 Error 对象可以有一条消息和一个名称（可以是您需要的类型，例如“RunCError”）。

runA()
    .then(runB)
    .then(runC)     // won't get called if runA or runB throws
    .then(runD)     // won't get called if runA or runB throws
    .catch(handleErrors)

function runA() {
    // ...

    if (err) {
        var error = new Error('Something is wrong...');
        error.name = 'RunAError';
        throw error;
    }
}

function runB() {
    // ...

    if (err) {
        var error = new Error('Something is wrong...');
        error.name = 'RunBError';
        throw error;
    }
}

function runC() {
    // ...

    if (err) {
        var error = new Error('Something is wrong...');
        error.name = 'RunCError';
        throw error;
    }
}

function runD() {
    // ...

    if (err) {
        var error = new Error('Something is wrong...');
        error.name = 'RunDError';
        throw error;
    }
}

function handleErrors(err) {
    if (err.name == 'RunAError') {
        handleAError();
    }

    if (err.name == 'RunBError') {
        handleBError();
    }

    // so on...
}

Answer 3

我刚刚偶然发现了同样的问题，到目前为止，我的解决方案是在 catch 中显式调用 reject，就像在这个 js bin 中一样：https://jsbin.com/yaqicikaza/edit?js,console

代码sn-p

const promise1 = new Promise( ( resolve, reject ) => reject( 42 ) );

promise1
  .catch( ( err ) => console.log( err ) ) // 42 will be thrown here
  .then( ( res ) => console.log( 'will execute' ) ) // then branch will execute


const promise2 = new Promise( ( resolve, reject ) => reject( 42 ) );

promise2
  .catch( ( err ) => Promise.reject( ) ) // trigger rejection down the line
  .then( ( res ) => console.log( 'will not execute' ) ) // this will be skipped