I'm trying async/await functionality. I have such code imitating a request:
const getJSON = async () => {
const request = () => new Promise((resolve, reject) => (
setTimeout(() => resolve({ foo: 'bar'}), 2000)
));
const json = await request();
return json;
}
When I use the code in this way
console.log(getJSON()); // returns Promise
it returns a Promise
but when I call this line of code
getJSON().then(json => console.log(json)); // prints { foo: 'bar' }
it prints json as expected
Is it possible to use just code like console.log(getJSON())
? What don't I understand?
Async functions always return a promise. If the return value of an async function is not explicitly a promise, it will be implicitly wrapped in a promise. Note: Even though the return value of an async function behaves as if it's wrapped in a Promise.resolve , they are not equivalent.
Inside an async function, you can use the await keyword before a call to a function that returns a promise. This makes the code wait at that point until the promise is settled, at which point the fulfilled value of the promise is treated as a return value, or the rejected value is thrown.
await is always for a single Promise . Promise creation starts the execution of asynchronous functionality. await only blocks the code execution within the async function. It only makes sure that the next line is executed when the promise resolves.
However, if you want to catch the rejected promise you're returning from an asynchronous function, then you should definitely use return await promise expression and add deliberately the await .
Every async
function returns a Promise
object. The await
statement operates on a Promise
, waiting until the Promise
resolve
s or reject
s.
So no, you can't do console.log
on the result of an async function directly, even if you use await
. Using await
will make your function wait and then return a Promise
which resolves immediately, but it won't unwrap the Promise
for you. You still need to unwrap the Promise
returned by the async
function, either using await
or using .then()
.
When you use .then()
instead of console.log
ging directly, the .then()
method makes the result of the Promise available to you. But you can't get the result of the Promise
from outside the Promise. That's part of the model of working with Promises.
A function defined with async
always returns a Promise
. If you return any other value that is not a Promise
, it will be implicitly wrapped in a Promise
. The statement const json = await request();
unwraps the Promise
returned by request()
to a plain object { foo: 'bar' }
. This is then wrapped in a Promise
before being returned from getJSON
so a Promise
is what you ultimately get when you call getJSON()
. So to unwrap it, you can either call getJSON().then()
like you've done or do await getJSON()
to get the resolved value.
Return value of an async function will always be an AsyncFunction Object, which will return a Promise
when called. You can not change that return type. The point of async/await
is to easily wait for other async process to complete inside an async function.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With