JavaScript Promises - reject vs throw

Question

I have read several articles on this subject  but it is still not clear to me if there is a difference between Promise reject vs  throwing an error  For example   Using Promise reject  return asyncIsPermitted        then function result            if  result     true                return true                    else               return Promise reject new PermissionDenied                         Using throw  return asyncIsPermitted        then function result            if  result     true                return true                    else               throw new PermissionDenied                        My preference is to use throw simply because it is shorter  but was wondering if there is any advantage of one over the other

User · Answer

Yes  the biggest difference is that reject is a callback function that gets carried out after the promise is rejected  whereas throw cannot be used asynchronously  If you chose to use reject  your code will continue to run normally in asynchronous fashion whereas throw will prioritize completing the resolver function  this function will run immediately   An example I ve seen that helped clarify the issue for me was that you could set a Timeout function with reject  for example   x000D   x000D  new Promise  resolve  reject    gt      setTimeout     gt  reject  err msg   console log  finished     1000     return resolve  ret val       then  o    gt  console log  RESOLVED   o    catch  o    gt  console log  REJECTED   o    x000D   x000D   x000D   The above could would not be possible to write with throw   x000D   x000D  try    new Promise  resolve  reject    gt        setTimeout     gt  throw new Error  err msg     1000       return resolve  ret val           then  o    gt  console log  RESOLVED   o      catch  o    gt  console log  REJECTED   o     catch o     console log  IGNORED   o    x000D   x000D   x000D   In the OP s small example the difference in indistinguishable but when dealing with more complicated asynchronous concept the difference between the two can be drastic

User · Answer

TLDR  A function is hard to use when it sometimes returns a promise and sometimes throws an exception  When writing an async function  prefer to signal failure by returning a rejected promise  Your particular example obfuscates some important distinctions between them    Because you are error handling inside a promise chain  thrown exceptions get automatically converted to rejected promises  This may explain why they seem to be interchangeable - they are not    Consider the situation below   checkCredentials        gt        let idToken   localStorage getItem  some token        if   idToken           return fetch  https   someValidateEndpoint             headers              Authorization   Bearer   idToken                            else         throw new Error  No Token Found In Local Storage               This would be an anti-pattern because you would then need to support both async and sync error cases   It might look something like   try     function onFulfilled         do the rest of your logic     function onRejected        handle async failure - like network timeout     checkCredentials x  then onFulfilled  onRejected     catch  e         Error  No Token Found In Local Storage        handle synchronous failure      Not good and here is exactly where Promise reject   available in the global scope   comes to the rescue and effectively differentiates itself from throw   The refactor now becomes   checkCredentials        gt      let idToken   localStorage getItem  some token      if   idToken        return Promise reject  No Token Found In Local Storage         return fetch  https   someValidateEndpoint         headers          Authorization   Bearer   idToken                  This now lets you use just one catch   for network failures and the synchronous error check for lack of tokens   checkCredentials          catch  error    gt  if   error     No Token               do no token modal         else if   error     400              do not authorized modal  etc

User · Answer

There is no advantage of using one vs the other  but  there is a specific case where throw won t work  However  those cases can be fixed  Any time you are inside of a promise callback  you can use throw  However  if you re in any other asynchronous callback  you must use reject  For example  this won t trigger the catch   x000D   x000D  new Promise function       setTimeout function         throw  or nah          return Promise reject  or nah    also won t work      1000      catch function e      console log e      doesn t happen     x000D   x000D   x000D   Instead you re left with an unresolved promise and an uncaught exception  That is a case where you would want to instead use reject  However  you could fix this in two ways   by using the original Promise s reject function inside the timeout    x000D   x000D  new Promise function resolve  reject      setTimeout function         reject  or nah         1000      catch function e      console log e      works      x000D   x000D   x000D    by promisifying the timeout    x000D   x000D  function timeout duration       Thanks joews   return new Promise function resolve        setTimeout resolve  duration            timeout 1000  then function       throw  worky         return Promise reject  worky    also works    catch function e      console log e       worky       x000D   x000D   x000D

User · Answer

The difference is ternary operator  You can use  return condition   someData   Promise reject new Error  not OK      You can t use  return condition   someData    throw new Error  not OK

User · Answer

An example to try out  Just change isVersionThrow to false to use reject instead of throw     x000D   x000D  const isVersionThrow   true x000D   x000D  class TestClass   x000D    async testFunction      x000D      if  isVersionThrow    x000D        console log  Throw version   x000D        throw new Error  Fail    x000D        else   x000D        console log  Reject version   x000D        return new Promise  resolve  reject    gt    x000D          reject new Error  Fail     x000D           x000D        x000D      x000D    x000D   x000D  const test   async      gt    x000D    const test   new TestClass   x000D    try   x000D      var response   await test testFunction   x000D      return response  x000D      catch  error    x000D      console log  ERROR RETURNED   x000D      throw error  x000D        x000D    x000D   x000D  test   x000D   then result   gt    x000D    console log  result      result  x000D     x000D   catch error   gt    x000D    console log  error      error  x000D     x000D   x000D   x000D

User · Answer

There s one difference      which shouldn t matter      that the other answers haven t touched on  so  There s no difference that s likely to matter  no  Yes  there is a very small difference  If the fulfillment handler passed to then throws  the promise returned by that call to then is rejected with what was thrown  If it returns a rejected promise  the promise returned by the call to then is resolved to that promise  and will ultimately be rejected  since the promise it s resolved to is rejected   which may introduce one extra async  quot tick quot   one more loop in the microtask queue  to put it in browser terms   Any code that relies on that difference is fundamentally broken  though   -  It shouldn t be that sensitive to the timing of the promise settlement  Here s an example   x000D   x000D  function usingThrow val        return Promise resolve val           then v   gt                if  v     42                    throw new Error    v  is not 42                               return v                function usingReject val        return Promise resolve val           then v   gt                if  v     42                    return Promise reject new Error    v  is not 42                                return v                    The rejection handler on this chain may be called   after   the    rejection handler on the following chain usingReject 1   then v   gt  console log v    catch e   gt  console error  Error from usingReject    e message        The rejection handler on this chain may be called   before   the    rejection handler on the preceding chain usingThrow 2   then v   gt  console log v    catch e   gt  console error  Error from usingThrow    e message    x000D   x000D   x000D   If you run that  as of this writing you get   Error from usingThrow  2 is not 42  Error from usingReject  1 is not 42   Note the order  Compare that to the same chains but both using usingThrow   x000D   x000D  function usingThrow val        return Promise resolve val           then v   gt                if  v     42                    throw new Error    v  is not 42                               return v                 usingThrow 1   then v   gt  console log v    catch e   gt  console error  Error from usingThrow    e message     usingThrow 2   then v   gt  console log v    catch e   gt  console error  Error from usingThrow    e message    x000D   x000D   x000D   which shows that the rejection handlers ran in the other order   Error from usingThrow  1 is not 42  Error from usingThrow  2 is not 42   I said  quot may quot  above because there s been some work in other areas that removed this unnecessary extra tick in other similar situations if all of the promises involved are native promises  not just thenables    Specifically  In an async function  return await x originally introduced an extra async tick vs  return x while being otherwise identical  ES2020 changed it so that if x is a native promise  the extra tick is removed   Again  any code that s that sensitive to the timing of the settlement of a promise is already broken  So really it doesn t shouldn t matter  In practical terms  as other answers have mentioned   As Kevin B pointed out  throw won t work if you re in a callback to some other function you ve used within your fulfillment handler      this is the biggie As lukyer pointed out  throw abruptly terminates the function  which can be useful  but you re using return in your example  which does the same thing  As Vencator pointed out  you can t use throw in a conditional expression        at least not for now  Other than that  it s mostly a matter of style preference  so as with most of those  agree with your team what you ll do  or that you don t care either way   and be consistent

User · Answer

Another important fact is that reject   DOES NOT terminate control flow like a return statement does  In contrast throw does terminate control flow    Example    x000D   x000D  new Promise  resolve  reject    gt    x000D    throw  err   x000D    console log  NEVER REACHED    x000D     x000D   then      gt  console log  RESOLVED    x000D   catch      gt  console log  REJECTED     x000D   x000D   x000D    vs   x000D   x000D  new Promise  resolve  reject    gt    x000D    reject       resolve   behaves similarly x000D    console log  ALWAYS REACHED        REJECTED  will print AFTER this x000D     x000D   then      gt  console log  RESOLVED    x000D   catch      gt  console log  REJECTED     x000D   x000D   x000D

[javascript] JavaScript Promises - reject vs. throw

Examples related to javascript

Examples related to promise