如何使用内部 Promise.all 处理外部 try catch 中的拒绝 promise 错误？

Question

当 detectionDog 或 detectionDog 发生错误/拒绝时，错误由detectingDog .catch(error of the detectingDog Promise.all()成功处理，但我希望该error由try结构的catch (err)直接处理。

我怎样才能做到这一点？

PS：我已经尝试摆脱.catch(error但随后Promise.all()永远挂起

try {
        function detectingDog(bufferedData) {
            return new Promise((resolve, reject) => {
                package.detectDog(bufferedData, function(error, data) {
                    if (error) {
                        reject(error);
                    } else {
                        return resolve(data);
                    }
                });
            });
        }                

        function detectingCat(bufferedData) {
            return new Promise((resolve, reject) => {
                package.detectCat(bufferedData, function(error, data) {
                    if (error) {
                        reject(error); 
                    } else {
                        return resolve(data); 
                    }
                });
            });
        }                

        Promise.all([
            detectingDog(param1),
            detectingCat(param2)
        ]).then(responseData => { 
            callback(undefined, responseData);                                         
        }).catch(error => { 
            // (1) I need to pass the error to the outer structure where error handling is done
        });
    } catch (err) {                
        console.log(err); 
           // handing of the inner error (2) here
        callback(err);                 
    }

谢谢！

Answer 1

...但我希望错误由try结构的catch (err)直接处理。

您不能在非async function 中执行此操作，因为在拒绝发生时控制已经离开了try / catch ，这是在此代码所在的任何 function（如果有）返回之后。

在async function 中，您可以在 promise 上使用await ，这将导致拒绝throw ，因此它将 go 用于您的try / catch 。 因此，您可以执行以下操作，但请继续阅读，因为这很奇怪：

// In an `async` function
try {
    function detectingDog(bufferedData) {
        return new Promise((resolve, reject) => {
            package.detectDog(bufferedData, function(error, data) {
                if (error) {
                    reject(error);
                } else {
                    return resolve(data);
                }
            });
        });
    }                

    function detectingCat(bufferedData) {
        return new Promise((resolve, reject) => {
            package.detectCat(bufferedData, function(error, data) {
                if (error) {
                    reject(error); 
                } else {
                    return resolve(data); 
                }
            });
        });
    }                

    const responseData = await Promise.all([
        detectingDog(param1),
        detectingCat(param2)
    ]);
    callback(responseData);
} catch (err) {                
    console.log(err); 
    callback(err);                 
}

...但是对于 go 来说，如果您只是要向调用者提供基于回调的 API，那么将回调 API 转换为承诺的麻烦并没有多大意义。 只需返回 promise。 这使得整个try / catch消失：

// No need for these to be nested
function detectingDog(bufferedData) {
    return new Promise((resolve, reject) => {
        package.detectDog(bufferedData, function(error, data) {
            if (error) {
                reject(error);
            } else {
                resolve(data); // No need for `return`
            }
        });
    });
}                

function detectingCat(bufferedData) {
    return new Promise((resolve, reject) => {
        package.detectCat(bufferedData, function(error, data) {
            if (error) {
                reject(error); 
            } else {
                resolve(data); 
            }
        });
    });
}                

function example(param1, param2) {
    return Promise.all([
        detectingDog(param1),
        detectingCat(param2)
    ]);
}

Answer 2

您在这里有两个选择。

如果您确实需要try/catch块，则需要在async function 中运行代码，利用等待被拒绝的 Promise 将在此上下文中引发错误的事实：

(async function () { // you might not need the immediately invoking function wrapper depending on your context
    try {
        function one(bufferedData) {
            // return a promise
        }                

        function two(bufferedData) {
            // return a Promise
        }                

        const responseData = await Promise.all([
            one(param1),
            two(param2)
        ])
        callback(undefined, responseData)
    } catch (err) {                
        console.log(err);
        // handing of the inner error (2) here
        callback(err)              
    }
})()

或者，您也可以只处理 Promise 链的 catch 块中的错误：

function one(bufferedData) {
    // return a promise
}                

function two(bufferedData) {
    // return a Promise
}                

Promise.all([
    one(param1),
    two(param2)
])
.then((responseData) => {
    callback(undefined, responseData)
})
.catch((err) => {    
    console.log(err);
    // handing of the inner error (2) here
    callback(err)              
})