Asynchronous Error Handling with Promise Chaining

When working with asynchronous code, it's crucial to consider how to handle errors effectively. Uncaught exceptions can crash your application, so it's important to have a strategy in place.

In the scenario described, a Promise is created with a setTimeout that throws an error. Bluebird Promise's catch handler will not catch this error because it occurs within an asynchronous callback.

Exception Handling within Promises

Promises, however, can catch exceptions that are thrown within their own callback functions. To handle this type of error, you can:

function getPromise() {
  return new Promise(function(done, reject) {
    setTimeout(done, 500);
  }).then(function() {
    console.log("hihihihi");
    throw new Error("Oh no!");
  });
}

Here, the error is thrown within the then callback, which ensures that it will be caught by the Promise's catch handler.

Caveats with Asynchronous Callbacks

It's crucial to remember that Promises do not catch exceptions from asynchronous callbacks that are not within their own purview. To handle these types of errors, consider:

1. Using Promise.delay: Promise.delay wraps an asynchronous callback to return a Promise. Any errors thrown within the callback will be caught by the Promise.
2. Rejecting the surrounding Promise: Whenever possible, reject the Promise surrounding the asynchronous callback instead of throwing an exception.

Example Handling of Rogue Async Callbacks

To handle a rogue async callback in Node.js or the browser, you can use the following approach:

function getPromise() {
  return new Promise(function(done, reject) {
    setTimeout(function() {
      try {
        // Your rogue async callback here
        console.log("hihihihi");
      } catch (e) {
        reject(e);
      }
    }, 500);
  });
}

By manually handling any exceptions within the callback, this approach ensures that they will not crash your application.