我无法弄清楚如何将嵌套的承诺链分解成主要的承诺链。这是我的代码:
//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()引发错误时,将不再执行主promise链中的functionC,因为nestedChain拒绝的promise也将破坏该链。
答案 0 :(得分:1)
您将必须附加诺言链,执行类似的操作
function nestedChain()
{
stepOne()
.then(stepTwo, chainError)
.then(stepThreee, chainError)
.catch ((error) => {
console.log(error);
return undefined;
})
}
答案 1 :(得分:1)
实现承诺以等待花费更多时间的事情。您只需要正确地实现Promise。
例如,如果我们有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 nestedFunc() {
return functionD() // Return promise
.then( result => {
return functionE(); // return promise
})
.then( result => {
return functionF(); // return promise or value
});
}
主诺言链不受单个函数的作用的影响,只要他们不断返回诺言即可。所有单个功能都可以具有本地承诺链。即使嵌套链中发生错误,主承诺链中的catch()
也会捕获该错误。
答案 2 :(得分:0)
如果我理解的正确,那么您需要在嵌套链承诺后捕获错误
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');
});