Placement of catch BEFORE and AFTER then

by

So, basically you’re asking what is the difference between these two (where p is a promise created from some previous code):

return p.then(...).catch(...);

and

return p.catch(...).then(...);

There are differences either when p resolves or rejects, but whether those differences matter or not depends upon what the code inside the .then() or .catch() handlers does.

What happens when p resolves:

In the first scheme, when p resolves, the .then() handler is called. If that .then() handler either returns a value or another promise that eventually resolves, then the .catch() handler is skipped. But, if the .then() handler either throws or returns a promise that eventually rejects, then the .catch() handler will execute for both a reject in the original promise p, but also an error that occurs in the .then() handler.

In the second scheme, when p resolves, the .then() handler is called. If that .then() handler either throws or returns a promise that eventually rejects, then the .catch() handler cannot catch that because it is before it in the chain.

So, that’s difference #1. If the .catch() handler is AFTER, then it can also catch errors inside the .then() handler.

What happens when p rejects:

Now, in the first scheme, if the promise p rejects, then the .then() handler is skipped and the .catch() handler will be called as you would expect. What you do in the .catch() handler determines what is returned as the final result. If you just return a value from the .catch() handler or return a promise that eventually resolves, then the promise chain switches to the resolved state because you “handled” the error and returned normally. If you throw or return a rejected promise in the .catch() handler, then the returned promise stays rejected.

In the second scheme, if the promise p rejects, then the .catch() handler is called. If you return a normal value or a promise that eventually resolves from the .catch() handler (thus “handling” the error), then the promise chain switches to the resolved state and the .then() handler after the .catch() will be called.

So that’s difference #2. If the .catch() handler is BEFORE, then it can handle the error and allow the .then() handler to still get called.

When to use which:

Use the first scheme if you want just one .catch() handler that can catch errors in either the original promise p or in the .then() handler and a reject from p should skip the .then() handler.

Use the second scheme if you want to be able to catch errors in the original promise p and maybe (depending upon conditions), allow the promise chain to continue as resolved, thus executing the .then() handler.

The other option

There’s one other option to use both callbacks that you can pass to .then() as in:

 p.then(fn1, fn2)

This guarantees that only one of fn1 or fn2 will ever be called. If p resolves, then fn1 will be called. If p rejects, then fn2 will be called. No change of outcome in fn1 can ever make fn2 get called or vice versa. So, if you want to make absolutely sure that only one of your two handlers is called regardless of what happens in the handlers themselves then you can use p.then(fn1, fn2).

More Related Contents:

  1. How do I convert an existing callback API to promises?
  2. When is .then(success, fail) considered an antipattern for promises?
  3. Is “.then(function(a){ return a; })” a no-op for promises?
  4. Correct way to write loops for promise.
  5. Asynchronous exception handling with bluebird promises
  6. Object method with ES6 / Bluebird promises
  7. Handling multiple catches in promise chain
  8. Limit concurrency of promise being run
  9. Catching Errors in JavaScript Promises with a First Level try … catch
  10. Are there still reasons to use promise libraries like Q or BlueBird now that we have ES6 promises? [closed]
  11. How do I handle errors with promises?
  12. How to promisify Node’s child_process.exec and child_process.execFile functions with Bluebird?
  13. Wait promise inside for loop
  14. Limit concurrency of pending promises
  15. What is the explicit promise construction antipattern and how do I avoid it?
  16. Issue in returning data retrieved from DB queries called in the loop
  17. Difference between microtask and macrotask within an event loop context
  18. Using async/await with a forEach loop
  19. Node JS Promise.all and forEach
  20. Understanding promises in Node.js
  21. How to check if an object is a Promise?
  22. Node exits without error and doesn’t await promise (Event callback)
  23. Nodejs express and promises not doing what I expect
  24. How do I use Bluebird with Angular?
  25. How to structure nested Promises
  26. Node.js: When to use Promises vs Callbacks
  27. Recursive Promises Not Returning
  28. what happens when a Promise never resolves? [duplicate]
  29. How to return a promise when writestream finishes?
  30. Weird behavior with Promise throwing “Unhandled promise rejection” error

Leave a Comment