没有“await”关键字的异步 function 返回“未捕获（承诺中）错误”

Question

I am fairly new to asynchronous functions and had experimented with the following scenarios:

Scenario A

async function foo() {
   const p2 = new Promise((_,reject) =>  reject('2')); //Uncaught (in promise) 2
}
foo().catch(() => {})

Scenario B

async function foo() {}
foo().catch(() => {})

My question is why does the error message occur in Scenario A? Both scenarios implicitly return a resolved promise with the value of "undefined," but only the error message shows on Scenario A. I also read that a promise without.catch() specified will hide its error message, but it clearly does not do so in the above example. I have been stuck for over an hour and any help is greatly appreciated!

Answer 1

You aren't returning your p2 promise from your function, therefore, there's no way for the caller to catch() the result of that promise. And, in this particular example, there is no reason for your function to be async since you aren't using await and you aren't throwing and expecting that to be turned into a rejected promise. So, your uncaught promise doesn't have anything to do with async here.

async function foo() {
   const p2 = new Promise((_,reject) =>  reject('2'));
   return p2;
}

foo().catch(() => {})

or remove the unnecessary async keyword:

function foo() {
   const p2 = new Promise((_,reject) =>  reject('2'));
   return p2;
}

foo().catch(() => {})

My question is why does the error message occur in Scenario A? Both scenarios implicitly return a resolved promise with the value of "undefined," but only the error message shows on Scenario A.

Because you're creating a promise p2 and then doing nothing with it. It isn't connected at all to the return value of foo() or to the promise that is automatically returned from the async function foo . It's just orphaned there by itself and thus nobody catches its error.

I also read that a promise without.catch() specified will hide its error message, but it clearly does not do so in the above example

You'd have to show us the context in which you read that because by itself that is not correct. A rejected promise where that rejection is never caught will cause a warning.

---

If you await your p2 promise, then the await is tied to the promise that the async function returns and that will work properly. So, this will work:

async function foo() {
   const p2 = new Promise((_,reject) =>  reject('2'));
   await p2;
}

foo().catch(() => {})

The await will see the rejection. That will then cause the promise that the async function returned to reject and the caller will see that rejection and your .catch() will catch it. Without the await , this is just an orphaned promise. async functions don't connect to all rejections inside them - they only connect to rejections that are awaited or are directly returned.