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();

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();

• javascript
• node.js
• async-await

Share Improve this question Follow edited Mar 18, 2019 at 21:37 ekkis 10.3k1313 gold badges6262 silver badges113113 bronze badges asked Mar 25, 2018 at 1:35 Henrique BorgesHenrique Borges 49966 silver badges1515 bronze badges 1

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

Add a ment  | 

2 Answers 2

Sorted by: Reset to default 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 */ }
  

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);
    }
}