This one will be short and sweet.
Can you tell what is wrong with this piece of code?
async function getAllUsers() {
try {
return fetchAllUsers(); // returns promise
}
catch (e) {
return new Error('never gonna happen')
}
}
So what is wrong with the first example? Well you see if the fetchAllUsers
function rejects, the catch
block inside the getAllUsers()
will never run.
The return result of getAllUsers()
is a promise that is not yet resolved. And if that promise rejects, it will never run the catch
block of getAllUsers()
, basically it will reject/throw
one level up.
const users = await getAllUsers()
//it will throw here
What you really want is:
async function getAllUsers() {
try {
return await fetchAllUsers(); // returns promise
}
catch (e) {
return new Error('oops')
}
}
Have you noticed the return await
? This way the try
block will return a resolved promise from the fetchAllUsers()
but if that promise rejects, the catch
block will run, and handle the rejection.
const users = await getAllUsers()
// users will have a value from try or catch block return statemen
It is a subtle but important difference, and can easily be missed.
Top comments (3)
Which one is more preferable, in case of performance?
Sorry for a late reply (notifications on dev.to are crazy stupid).
In case of
return await
it will have one more microtask, you can think of it as one morethen()
added to the promise chain. So if you need to catch the error that is what you should use. If you plan on handling errors somewhere else in your code then just usereturn
(withoutawait
).thank you <3