从 JavaScript 中的函数返回结果后如何处理函数的意外错误？

Question

在处理 JavaScript 中的异步函数时。我发现了这个问题。

函数需要执行一些异步任务，但是该任务对函数结果没有影响。所以函数返回它的结果，一段时间后，异步函数抛出异常，但是由于控制已经返回，所以异常没有处理。

注意：不要更改notify我故意抛出这样的错误，只需要处理这个异常

代码如下：

function notify() {   //To send notification
    setTimeout( function() {   //Just to simulate an asynchronous function
        throw "Exception occurred";   //An exception from async function
    },2000);

    return "Notified";
}

try {
    let result = notify();
    console.log(result);    //Notified
}
catch (error) {   //Never comes to catch block.
    console.log(error);
}

如何捕捉这个异常。 尝试使用 Promise，但它不能通过 Promise 解决，因为即使使用 Promise，由于调用函数已收到响应，流或函数也会从内存中删除。

使用承诺的代码

function notify() {   //To send notification

    return new Promise ( (resolve, reject) => {
        setTimeout( function() {   //Just to simulate an asynchronous function
            throw "Exception occurred";   //An exception from async function
        },2000);

        resolve("Notified");
    });
}

notify()
.then( result => {
    console.log(result);    //Notified
})
.catch( error => {   //Never comes to catch block
    console.log(error);
});

如何在 JavaScript 编程中捕获异常？

Answer 1

    var notify = function () {
        anOddTask();
        return "Notified";
    }


    async function anOddTask() {
        try {
            await setTimeout( function() {  
            },2000);
            throw new Error("Exception occurred");
        }
        catch (err) {   
            console.log(err);
        }
    }

    try {
        let result = notify();
        console.log(result);    //Notified
    }
    catch (error) {   //Never comes to catch block.
        console.log(error);
    }

这将立即返回“通知”并在稍后处理拒绝。如果您希望“通知”作为已解决的承诺返回，而不仅仅是将 notify() 设为异步函数。

    var notify = async function () {
        anOddTask();
        return "Notified";
    }

Answer 2

我会将 setTimeout 包装在一个承诺中：

  const delay = ms => new Promise(res => setTimeout(res, ms));

这允许您将notify 写为：

  async function notify() {
    await delay(2000);
    throw new Error();
  }

  notify().then(/*...*/).catch(/*...*/);

这里的诀窍是 throw 在异步函数内部，而不是在回调内部。