Handling Js promise rejection

Question

How do you handle an error (eg. "new error" below) that is outside of the promise?

function testError() {
    throw new Error("new error") // how to handle this?
    var p123 = new Promise(function(resolve, reject) {
         resolve(123)
    });
    return p123
};

testError().catch(err => {
        return err;  // code doesn't come here
    })
    .then(ok => {
        console.log(ok)
    });

You'll have to throw the error inside the promise function for the .catch() to work. — Shilly, Apr 14 '17 at 07:19
See [How can I catch an asynchronous error using JS promises?](http://stackoverflow.com/questions/42755042/how-can-i-catch-an-asynchronous-error-using-js-promises/42755300#42755300) — guest271314, Apr 14 '17 at 07:25

score 6 · Accepted Answer · answered Apr 14 '17 at 07:20

If you're not sure whether a function will throw (or return a value) synchronously, you can call it using .then(). This will wrap it so that the result will be handled consistently no matter how it is produced:

function testError() {
  throw new Error("new error") // how to handle this?
  var p123 = new Promise(function(resolve, reject) {
    resolve(123)
  });
  return p123
};

Promise.resolve()
  .then(testError)
  .catch(err => {
    console.error(err);
    return err; 
  })
  .then(ok => {
    console.log(ok.message)
  });

Note that, since ES2018, you can use .finally() instead of the second .then() call, which does the same thing but is clearer as to the intention (It will always be called, even if the promise error'd out). — batjko, Mar 20 '18 at 08:32

Wiktor Zychla · Answer 2 · 2017-04-14T08:02:04.677

4

Since the error doesn't involve the async code, a regular try-catch should do fine here:

try {
  testError().catch(err => {
    return err;  // code doesn't come here
  })
  .then(ok => {
     console.log(ok)
  });
}
catch(e) {
   // 
}

Note that when the async-await pattern finally becomes the native way of resolving promises, the try-catch will also become the native way of handling errors:

try {
    var ok = await testError();
    console.log(ok)
}
catch(e) {
    console.log('e:' +e);
}

As one can easily verify, this one correctly handles both the sync and the async error and is much cleaner than then-catch.

edited Apr 14 '17 at 08:02

answered Apr 14 '17 at 07:21

Wiktor Zychla

47,367
6
74
106

This will work, but it makes the logic flow very messy and destroys the uniformity that promises provide. – JLRishe Apr 14 '17 at 07:25
@JLRishe: addressed this in my answer - the `try-catch` provides the ultimate uniformity. – Wiktor Zychla Apr 14 '17 at 08:02
It does if `async`/`await` are available, but not when they aren't available. – JLRishe Apr 14 '17 at 08:07

score 1 · Answer 3 · answered Apr 14 '17 at 08:32

If you can, rewrite your testError function like so

function testError () {
  return new Promise(function (resolve, reject) {
     throw new Error('new error')
     resolve(123)
  })
}

testError().then(ok => console.log(ok),
                 err => console.error(err.message))

Run it once to see it throw the error in console.error
Comment out the throw line to see the promise resolve successfully

score 0 · Answer 4 · answered Apr 14 '17 at 07:22

Since the error is thrown outside of the promises, you cannot catch it using a promise catch statement.

You can use a try/catch to catch the error instead.

function testError() {
    throw new Error("new error") // how to handle this?
    var p123 = new Promise(function(resolve, reject) {
         resolve(123)
    });
    return p123
};

try {
  testError().then(ok => {
    console.log(ok)
  });
} catch (err) {
  console.log(err.message);
}

jib · Answer 5 · 2017-04-15T04:39:13.783

You rewrite it, because making a caller check for both exceptions and rejections is an anti-pattern:

function testError() {
  return Promise.resolve().then(() => {
    throw new Error("new error"); // rejects returned promise
    return new Promise(function(resolve) {
      resolve(123);
    });
  });
}

testError().catch(err => console.log("Caught " + err));

This is implicit with async functions; they always return a promise:

async function testError() {
  throw new Error("new error"); // rejects implicit promise
  return await new Promise(function(resolve) {
    resolve(123);
  });
}

testError().catch(err => console.log("Caught " + err));

Handling Js promise rejection

5 Answers5