Node.JS - Can`t get async throws with try/catch blocks

Question

When I create an async function in node and use await, I'm making the execution waits for a promise resolution (that can be a resolve or a rejection), what I do is put an await promise inside a try/catch block and throw an error in case of a promise rejection. The problem is, when I call this async function inside a try/catch block to catch the error in case of it, I get an UnhandledPromiseRejectionWarning. But the whole point of using await isn't waiting for the promise to resolve and return it's result? It seems like my async function is returning a promise.

Example - The code an UnhandledPromiseRejectionWarning:

let test = async () => {
   let promise = new Promise((resolve, reject) => {
      if(true) reject("reject!");
      else resolve("resolve!");
   });
   try{
      let result = await promise;
   }
   catch(error) {
      console.log("promise error =", error);
      throw error;
   }
}

let main = () => {
   try {
      test();
   }
   catch(error){
      console.log("error in main() =", error);
   }
}

console.log("Starting test");
main();

Possible duplicate of NodeJS UnhandledPromiseRejectionWarning — Ele
– Ele, Commented Mar 25, 2018 at 1:36

Catalyst · Accepted Answer · 2020-01-10 05:02:25Z

7

async functions always return promises. In fact, they always return native promises (even if you returned a bluebird or a constant). The point of async/await is to reduce the version of .then callback hell. Your program will still have to have at least one .catch in the main function to handle any errors that get to the top.

It is really nice for sequential async calls, e.g.;

async function a() { /* do some network call, return a promise */ }

async function b(aResult) { /* do some network call, return a promise */ }

async function c() {
   const firstRes = (await (a() /* promise */) /* not promise */);
   const secondRes = await b(firstRes/* still not a promise*/);
}

You cannot await something without being inside a function. Usually this means your main function, or init or whatever you call it, is not async. This means it cannot call await and must use .catch to handle any errors or else they will be unhandled rejections. At some point in the node versions, these will start taking out your node process.

Think about async as returning a native promise - no matter what - and await as unwrapping a promise "synchronously".

note async functions return native promises, which do not resolve or reject synchronously:

Promise.resolve(2).then(r => console.log(r)); console.log(3); // 3 printed before 2
Promise.reject(new Error('2)).catch(e => console.log(e.message)); console.log(3); // 3 before 2

async functions return sync errors as rejected promises.

async function a() { throw new Error('test error'); }

// the following are true if a is defined this way too
async function a() { return Promise.reject(new Error('test error')); }

/* won't work */ try { a() } catch(e) { /* will not run */ }

/* will work */ try { await a() } catch (e) { /* will run */ }

/* will work */ a().catch(e => /* will run */)

/* won't _always_ work */ try { return a(); } catch(e) { /* will not usually run, depends on your promise unwrapping behavior */ }

edited Jan 10, 2020 at 5:02

answered Mar 25, 2018 at 1:37

Catalyst

3,23720 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

Henrique Borges Over a year ago

Ok, but I have already used the try/catch block inside function test to handle the promise rejection. Why can't I throw an error and get this error at function main?

Catalyst Over a year ago

no matter what you do, an async function returns a promise. You can literally do async () => 2 and that's still going to return a promise. The nice thing about async/await is that it normalizes all returns, regardless of what happens inside the async function. This way we don't have to deal with functions that sometimes throw synchronously, and sometimes return a rejected promise.

Catalyst Over a year ago

@HenriqueBorges to be clear - test is an async function, it will never throw traditionally - something has to await it or use .catch

Henrique Borges Over a year ago

Oh I got it now, thanks a lot for the patience and the explanation @Catalyst. I'm really grateful. Now back to the code :)

MrCranky Over a year ago

Maybe worth another example, that try { return a(); } catch(e) {} will not work. I got caught by this - when converting Promise.then.catch patterns into async / await functions it's tempting to not do an await on the final promise in the function because it's superfluous. But if you're also enclosing that in a try / catch block, the catch will never work, because the lack of await means the exception / reject inside the block is never 'unwrapped'. return await a() will get caught, return a() won't.

|

Simon · Accepted Answer · 2018-11-21 17:14:43Z

-1

Main must be an async function to catch async errors

// wont work
let main = () =>{
    try{
        test();
    }catch(error){
        console.log("error in main() =", error);
    }
}

// will work
let main = async () =>{
    try{
        test();
    }catch(error){
        console.log("error in main() =", error);
    }
}

answered Nov 21, 2018 at 17:14

Simon

1,4883 gold badges13 silver badges24 bronze badges

Collectives™ on Stack Overflow

Node.JS - Can`t get async throws with try/catch blocks

2 Answers 2

9 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

9 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related