I have been going over async
/await
and after going over several articles, I decided to test things myself. However, I can't seem to wrap my head around why this does not work:
async function main() {
var value = await Promise.resolve('Hey there');
console.log('inside: ' + value);
return value;
}
var text = main();
console.log('outside: ' + text);
The console outputs the following (node v8.6.0) :
> outside: [object Promise]
> inside: Hey there
Why does the log message inside the function execute afterwards? I thought the reason async
/await
was created was in order to perform synchronous execution using asynchronous tasks.
Is there a way could I use the value returned inside the function without using a .then()
after main()
?
This question is related to
javascript
node.js
async-await
ecmascript-2017
To give some further info on top of current answers:
The contents of a node.js
file are currently concatenated, in a string-like way, to form a function body.
For example if you have a file test.js
:
// Amazing test file!
console.log('Test!');
Then node.js
will secretly concatenate a function that looks like:
function(require, __dirname, ... perhaps more top-level properties) {
// Amazing test file!
console.log('Test!');
}
The major thing to note, is that the resulting function is NOT an async function. So you cannot use the term await
directly inside of it!
But say you need to work with promises in this file, then there are two possible methods:
await
directly inside the functionawait
Option 1 requires us to create a new scope (and this scope can be async
, because we have control over it):
// Amazing test file!
// Create a new async function (a new scope) and immediately call it!
(async () => {
await new Promise(...);
console.log('Test!');
})();
Option 2 requires us to use the object-oriented promise API (the less pretty but equally functional paradigm of working with promises)
// Amazing test file!
// Create some sort of promise...
let myPromise = new Promise(...);
// Now use the object-oriented API
myPromise.then(() => console.log('Test!'));
It would be interesting to see node add support for top-level await
!
You can now use top level await in Node v13.3.0
import axios from "axios";
const { data } = await axios.get("https://api.namefake.com/");
console.log(data);
run it with --harmony-top-level-await
flag
node --harmony-top-level-await index.js
Top-level await is a feature of the upcoming EcmaScript standard. Currently, you can start using it with TypeScript 3.8 (in RC version at this time).
You can start using TypeScript 3.8 by installing it from npm using the following command:
$ npm install typescript@rc
At this time, you need to add the rc
tag to install the latest typescript 3.8 version.
Top-Level await
has moved to stage 3, so the answer to your question How can I use async/await at the top level? is to just add await
the call to main()
:
async function main() {
var value = await Promise.resolve('Hey there');
console.log('inside: ' + value);
return value;
}
var text = await main();
console.log('outside: ' + text)
Or just:
const text = await Promise.resolve('Hey there');
console.log('outside: ' + text)
--harmony-top-level-await
i like this clever syntax to do async work from an entrypoint
void async function main() {
await doSomeWork()
await doMoreWork()
}()
Since main()
runs asynchronously it returns a promise. You have to get the result in then()
method. And because then()
returns promise too, you have to call process.exit()
to end the program.
main()
.then(
(text) => { console.log('outside: ' + text) },
(err) => { console.log(err) }
)
.then(() => { process.exit() } )
The actual solution to this problem is to approach it differently.
Probably your goal is some sort of initialization which typically happens at the top level of an application.
The solution is to ensure that there is only ever one single JavaScript statement at the top level of your application. If you have only one statement at the top of your application, then you are free to use async/await at every other point everwhere (subject of course to normal syntax rules)
Put another way, wrap your entire top level in a function so that it is no longer the top level and that solves the question of how to run async/await at the top level of an application - you don't.
This is what the top level of your application should look like:
import {application} from './server'
application();
Node -
You can run node --experimental-repl-await
while in the REPL. I'm not so sure about scripting.
Deno -
Deno already has it built in.
Source: Stackoverflow.com