按顺序解析promise，如果序列中的promise之一抛出错误，则中断序列[重复]

Question

假设我有三个async函数设置如下：

const stepOne = async () => { setTimeout(function() {
  console.log("step 1")
}, 3000)  }

const stepTwo = async () => { throw new Error("Error at step two") }

const stepThree = async () => { console.log("step 3") }

我将如何顺序执行所有这些函数，并在第二步打破promise链，不允许第三步函数永远运行？

所以

正常的顺序是这样的：第一步--

在步骤二抛出错误的序列：步骤一--

第二步抛出的错误需要在end catch块中捕获。

更新#1：错过了这个问题的一个关键元素。wait不能被使用，因为这三个函数需要在一个不是异步的函数中调用。

例子：

const testFunc = () => { 
  
  resolve three promises 
  sequentially, break the promise chain when error is thrown 
  and ultimately, catch errors here
   
  }

Answer 1

如果您的步骤是返回promise的函数，则可以创建一个包装器函数，该函数将按顺序调用每个步骤，并在步骤失败时中止，记录失败步骤的详细信息。

在本例中，每一步失败的几率为1/5。

// Make a step proc, that throws 1 time in 5
function createStep(index) {
    let error = (Math.random() < 0.2) ? new Error(`Step ${index+1} error`) : null ;
    return () => new Promise((resolve, reject) => setTimeout(error ? reject(error): resolve(`Step ${index+1} outcome`), 500));
}

async function runSteps(steps) {
   
   for(stepIndex = 0; stepIndex < steps.length; stepIndex++) {
       try {
         console.log(`Running step #${stepIndex+1}...`);
         let result = await steps[stepIndex]();
         console.log(`Step result:`, result);
       } catch (e) { 
         console.error(`An error occurred at step #${stepIndex+1}:`, e.message);
         break;
       }
       if (stepIndex === (steps.length -1) ) {
          console.log("All steps completed successfully");
       }
   }
}

let steps = Array.from( { length: 3 }, (v,k) => createStep(k));
runSteps(steps);

Answer 2

请尝试下面的代码。您需要等待每次呼叫（第一步、第二步和第三步），以便在出现任何异常时，不会进行下一次呼叫。

try {
    await stepOne();
    await stepTwo();
    await stepThree()
} catch (error) {
    console.log(error);
}

Answer 3

如果您要从stepOne解析promise，那么您的代码就可以工作，因为setTimeout只是将函数添加到堆栈中，而不是等待它解析。

如果您要从stepOne返回一个Promise并在console.log之后解决它，那么try cat将等待stepOne并在stepTwo上捕获错误

这是您的代码示例

const stepOne = async () => {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            console.log("step 1")
            resolve(true);
        }, 3000)
    });
}

const stepTwo = async () => { throw new Error("Error at step two") }

const stepThree = async () => {
    return new Promise((resolve, reject) => {
        setTimeout(function() {
            console.log("step 3")
            resolve(true);
        }, 3000)
    });
}


(() => {
    stepOne()
        .then(stepTwo)
        .then(stepThree)
        .catch(error => {
            console.log(error);
        })  
})();

现在console.log看起来像这样

step 1
Error: Error at step two
    at stepTwo (/home/user/develop/test/stackoverflow.js:10:38)
    at processTicksAndRejections (internal/process/task_queues.js:93:5)