如何在承诺中捕捉未被发现的异常-HowtocatchuncaughtexceptioninPromise

18  

Update, native promises now do the following in most browsers:

更新，本地承诺现在在大多数浏览器做以下事情:

window.addEventListener("unhandledrejection", function(err, promise) { 
    // handle error here, for example log   
});

We were just discussing this the other day.

前几天我们刚刚讨论过这个问题。

Here is how you'd do this with bluebird:

这是你如何对付蓝鸟的方法:

window.Onpossiblyunhandledexception= function(){
    window.onerror.apply(this, arguments); // call
}

window.Onerror= function(err){
    console.log(err); // logs all errors
}

With Bluebird it's also possible to use Promise.onPossiblyUnhandledRejection. The calls for done are not needed as the library will detect unhandled rejection itself unlike Q (UPDATE 2016 - I now wrote code for Q and it does this).

对于蓝鸟来说，也可以使用promi .on表示不可能完成的任务。不需要调用done，因为库将检测未处理的拒绝本身，不像Q(更新2016 -我现在为Q编写代码，它这样做)。

As for native promises - they will eventually report to either window.onerror or a new handler but the specification process is not yet done - you can follow it here.

至于本地承诺——它们最终将向任一窗口报告。onerror或新的处理程序，但是规范过程还没有完成——您可以在这里跟踪它。

15  

Most promise implementations don't currently provide the type of functionality you are referring to, but a number of 3rd-party promise libraries (including Q and bluebird) provide a done() method that will catch and rethrow any uncaught errors, thus outputting them to the console.

大多数承诺实现目前不提供您正在引用的功能类型，但是许多第三方承诺库(包括Q和bluebird)提供了一个done()方法，可以捕获和重新抛出未捕获的错误，从而将它们输出到控制台。

(Edit: see Benjamin Gruenbaum's answer about Bluebird's features for handling uncaught exceptions)

(编辑:参见本杰明·格伦鲍姆(Benjamin Gruenbaum)关于知更鸟处理未捕获异常的特性的回答)

So if you have that, you'd just need to follow the rule of thumb that any promise you use should either be returned or terminated with .done():

因此，如果你有这样的经验，你只需要遵循经验法则，你使用的任何承诺都应该被退回或终止。

pr.then(function(result){
    console.log(result);
})
.done();

To quote from the Q API reference:

引用Q API参考:

The Golden Rule of done vs. then usage is: either return your promise to someone else, or if the chain ends with you, call done to terminate it. Terminating with catch is not sufficient because the catch handler may itself throw an error.

“完成”和“使用”的黄金法则是:要么把你的承诺归还给别人，要么，如果链终止于你，你就可以终止它。使用catch终止是不够的，因为catch处理程序本身可能抛出错误。

I realize that this still requires a bit of extra work and you can still forget to do this, but it is an improvement over having to .catch() and explicitly handle every error, especially for the reason pointed out above.

我意识到这仍然需要一些额外的工作，您仍然可以忘记这样做，但是这比必须要.catch()并显式地处理每个错误要好，特别是由于上面提到的原因。

4  

In Node.js, you can use:

在节点。js,您可以使用:

process.on('unhandledRejection', (reason, promise) => {
  console.error(`Uncaught error in`, promise);
});

2  

If you're writing code that can be executed both in a browser & in a Node.js environment, you could wrap your code in a self-executing function like this :

如果您正在编写可以在浏览器和节点中执行的代码。js环境下，可以将代码封装在一个自执行函数中，如下所示:

var isNode = (typeof process !== 'undefined' && typeof process.on !== 'undefined');
(function(on, unhandledRejection) {
    // PUT ANY CODE HERE
    on(unhandledRejection, function(error, promise) {
        console.error(`Uncaught error in`, promise);
    });
    // PUT ANY CODE HERE
})(
    isNode ? process.on.bind(process) : window.addEventListener.bind(window),
    isNode ? "unhandledRejection" : "unhandledrejection"
);

What would happen if you use this code :

如果您使用此代码会发生什么:

• If you'd run it in a Node.js environment, your handler would be attached to the process object and be executed when you have an uncaught exception in a promise.

  如果你在一个节点上运行它。在js环境中，您的处理程序将被附加到流程对象，并在承诺中出现未捕获异常时执行。

• If you'd run it in a browser environment, your handler would be attached to the window object and be executed when you have an uncaught exception in a promise and your browser supports the unhandledrejection event.

  如果您在浏览器环境中运行它，您的处理程序将被附加到窗口对象，当您在一个承诺中有一个未被捕获的异常并且您的浏览器支持unhandledrejection事件时将被执行。

• If you'd run it in a browser environment without support for the unhandledrejection, you will not be able to catch your uncaught exception and your unhandledrejection event handler will never be triggered, but you would not get any errors if there's no uncaught exceptions.

  如果您在不支持unhandledrejection的浏览器环境中运行它，您将无法捕获未捕获的异常，也不会触发unhandledrejection事件处理程序，但是如果没有未捕获的异常，您将不会得到任何错误。

0  

If you are using native Promise, it's pretty simple.
You only need to .catch this reject some where.

如果你使用的是原生承诺，这很简单。你只需要。抓住这个拒绝的地方。

ajax(request).catch(function(rejected){
      console.log(rejected);
});

If I don't catch it somewhere, the uncaught in promise will keep showing. But If I catch it somewhere...

如果我没有在某个地方发现它，未被发现的承诺将继续显现。但是如果我在什么地方抓到它……