Node.js 如何打破嵌套在另一个承诺链中的承诺链

我无法理解如何将嵌套的承诺链分解为主承诺链。这是我的密码：

 //Main Promise chain
 let promiseMain = Promise.resolve(1)
        .then(result => functionA())
        .then(result => nestedChain()).catch((error) => {
            console.log(error);
        })
        .then(result => functionC())

//chain error handler
function chainError(err) {
return Promise.reject(err)
};

function nestedChain()
{
stepOne()
.then(stepTwo, chainError)
.then(stepThreee, chainError)
.catch((error) => 
    {
        console.log(error);
        return undefined;
    });          
}

function stepOne() 
{
    return chainError("error attempt : 1.00");
}

一旦我进入nestedChain，在stepOne（）中抛出一个错误，我就能够打破这个nestedChain。太棒了

---

问题是：它也打破了主要的承诺链。所以当它进入nestedChain（）并从stepOne（）抛出错误时，来自主承诺链的functionC将永远不会执行，因为来自nestedChain的被拒绝承诺也会破坏此链。

您必须附加承诺链，请执行以下操作

function nestedChain()
{ 
  stepOne()
  .then(stepTwo, chainError)
  .then(stepThreee, chainError)
  .catch ((error) => {
               console.log(error);
               return undefined;
            })
}

function nestedFunc() {
    return functionD()          // Return promise
    .then( result => {
        return functionE();     // return promise
    })
    .then( result => {
        return functionF();      // return promise or value
    });
}

---

你将不得不附加承诺链，这样做

function nestedChain()
{ 
  stepOne()
  .then(stepTwo, chainError)
  .then(stepThreee, chainError)
  .catch ((error) => {
               console.log(error);
               return undefined;
            })
}

function nestedFunc() {
    return functionD()          // Return promise
    .then( result => {
        return functionE();     // return promise
    })
    .then( result => {
        return functionF();      // return promise or value
    });
}

---

若我理解你们的意思是正确的，你们需要捕捉嵌套链承诺后的错误

Promise.resolve().then(()=> {
  console.log('A');
}).then(() => {
  return Promise.resolve().then(() => {
    console.log('step 1');
  }).then(() => {
    console.log('step 2');
    throw new Error('Step 2 error');
  });
}).catch((err) => {
  console.log(err);
}).then(() => {
  console.log('C');
});

---

若我理解你们的意思是正确的，你们需要捕捉嵌套链承诺后的错误

Promise.resolve().then(()=> {
  console.log('A');
}).then(() => {
  return Promise.resolve().then(() => {
    console.log('step 1');
  }).then(() => {
    console.log('step 2');
    throw new Error('Step 2 error');
  });
}).catch((err) => {
  console.log(err);
}).then(() => {
  console.log('C');
});

---

履行承诺是为了等待需要更多时间的事情。你只需要正确地履行承诺

例如，如果我们有3个函数返回承诺，一个嵌套函数也返回承诺，那么它的实现方式如下：

functionA()
.then( result => {
    return functionB();
})
.then( result => {
    return nestedFunct();
})
.then( result => {
    return functionC();
})
.then( result => {
    console.log(result);
})
.catch( error => {
    console.log(`Error in one of the above function`);
});

所有函数的格式也很相似

function functionA() {
    return new Promise( (resilve, reject) => {
        resolve('something');
        // or
        reject('Error');
    });
}

嵌套函数可以是这样的

function nestedChain()
{ 
  stepOne()
  .then(stepTwo, chainError)
  .then(stepThreee, chainError)
  .catch ((error) => {
               console.log(error);
               return undefined;
            })
}

function nestedFunc() {
    return functionD()          // Return promise
    .then( result => {
        return functionE();     // return promise
    })
    .then( result => {
        return functionF();      // return promise or value
    });
}

---

主承诺链不受单个函数所做操作的影响，只要它们保持返回承诺。所有单个函数都可以有一个局部承诺链。即使嵌套链中发生错误，也会被主承诺链中的

catch（）

捕获。

承诺被实现以等待花费更多时间的事情。你只需要正确地履行承诺

例如，如果我们有3个函数返回承诺，一个嵌套函数也返回承诺，那么它的实现方式如下：

functionA()
.then( result => {
    return functionB();
})
.then( result => {
    return nestedFunct();
})
.then( result => {
    return functionC();
})
.then( result => {
    console.log(result);
})
.catch( error => {
    console.log(`Error in one of the above function`);
});

所有函数的格式也很相似

function functionA() {
    return new Promise( (resilve, reject) => {
        resolve('something');
        // or
        reject('Error');
    });
}

嵌套函数可以是这样的

function nestedChain()
{ 
  stepOne()
  .then(stepTwo, chainError)
  .then(stepThreee, chainError)
  .catch ((error) => {
               console.log(error);
               return undefined;
            })
}

function nestedFunc() {
    return functionD()          // Return promise
    .then( result => {
        return functionE();     // return promise
    })
    .then( result => {
        return functionF();      // return promise or value
    });
}

---

主承诺链不受单个函数所做操作的影响，只要它们保持返回承诺。所有单个函数都可以有一个局部承诺链。即使嵌套链中发生错误，主承诺链中的

catch（）

也会捕获。

promise

s不会抛出-您正在考虑的是

async

/

wait

所显示的行为，它用try/catch来解释我的失败，谢谢！但是。。是否可能仅在嵌套链中断开？

Promise

s不会抛出-您想到的是

async

/

wait

所显示的行为，这些行为解释了我的try/catch失败，谢谢！但是。。是否可以仅在嵌套链中中断？我在stepOne（）中抛出了一个错误，尝试了此操作，但遭到了未处理的拒绝，所有内容都会中断主链。发布完整的代码，错误必须在其他地方抛出，如果可能，请附加错误日志我在stepOne（）中抛出了一个错误，尝试了此操作我得到了一个未处理的拒绝，所有的东西都破坏了主链。发布完整的代码，错误一定是在其他地方抛出的，如果可能的话，附加错误日志如果我发现错误，代码仍在运行，它不会破坏嵌套链。另外，如果我捕捉到从嵌套链抛出到主链中的错误，主链不会捕捉任何东西。父链可以捕捉嵌套链抛出错误中的错误。你到底想做什么。我对你的评论感到困惑：）如果我发现了错误，代码仍在运行，并且不会破坏嵌套链。另外，如果我捕捉到从嵌套链抛出到主链中的错误，主链不会捕捉任何东西。父链可以捕捉嵌套链抛出错误中的错误。你到底想做什么。我对你的评论感到困惑：）