Como posso usar o assíncrono / aguardar no nível superior?

Fui revisando async/ awaite depois de revisar vários artigos, decidi testar as coisas sozinho. No entanto, não consigo entender por que isso não funciona:

async function main() {  
    var value = await Promise.resolve('Hey there');
    console.log('inside: ' + value);
    return value;
}

var text = main();  
console.log('outside: ' + text);

O console produz o seguinte (nó v8.6.0):

> fora: [promessa do objeto]

> dentro: Olá

Por que a mensagem de log dentro da função é executada posteriormente? Eu pensei que o motivo async/ awaitfoi criado era para executar a execução síncrona usando tarefas assíncronas.

Existe uma maneira de eu usar o valor retornado dentro da função sem usar um .then()depois main()?

Não consigo entender por que isso não funciona.

Porque mainretorna uma promessa; todas as asyncfunções fazem.

No nível superior, você deve:

1. Use uma asyncfunção de nível superior que nunca rejeite (a menos que você queira erros de "rejeição sem tratamento") ou

2. Use thene catch, ou

3. (Em breve!) Use nível superiorawait , uma proposta que atingiu o Estágio 3 no processo que permite o uso de nível superior awaitem um módulo.

# 1 - asyncFunção de nível superior que nunca rejeita

(async () => {
    try {
        var text = await main();
        console.log(text);
    } catch (e) {
        // Deal with the fact the chain failed
    }
})();

Observe o catch; você deve lidar com exceções de rejeição de promessa / assíncrono, pois nada mais será necessário; você não tem quem ligar para eles. Se preferir, você pode fazer isso com o resultado da chamada através da catchfunção (em vez de try/ catchsintaxe):

(async () => {
    var text = await main();
    console.log(text);
})().catch(e => {
    // Deal with the fact the chain failed
});

... que é um pouco mais conciso (eu gosto por esse motivo).

Ou, é claro, não lide com erros e permita apenas o erro "rejeição sem tratamento".

# 2 - thenecatch

main()
    .then(text => {
        console.log(text);
    })
    .catch(err => {
        // Deal with the fact the chain failed
    });

O catchmanipulador será chamado se ocorrerem erros na cadeia ou no seu thenmanipulador. (Certifique-se de que seu catchmanipulador não gere erros, pois nada está registrado para lidar com eles.)

Ou ambos os argumentos para then:

main().then(
    text => {
        console.log(text);
    },
    err => {
        // Deal with the fact the chain failed
    }
);

Mais uma vez, observe que estamos registrando um manipulador de rejeição. Mas, neste formulário, verifique se nenhum dos seus thenretornos de chamada não gera erros, nada é registrado para lidar com eles.

Nível 3 awaitem um módulo

Você não pode usar awaitno nível superior de um script que não seja do módulo, mas a proposta de nível superiorawait ( Estágio 3 ) permite usá-lo no nível superior de um módulo. É semelhante ao uso de um asyncwrapper de função de nível superior (nº 1 acima), pois você não deseja que seu código de nível superior rejeite (gere um erro) porque isso resultará em um erro de rejeição sem tratamento. Portanto, a menos que você queira ter essa rejeição sem tratamento quando as coisas derem errado, como no número 1, convém agrupar seu código em um manipulador de erros:

// In a module, once the top-level `await` proposal lands
try {
    var text = await main();
    console.log(text);
} catch (e) {
    // Deal with the fact the chain failed
}

Observe que, se você fizer isso, qualquer módulo que importe do seu módulo aguardará até que a promessa que você está fazendo seja awaitestabelecida; quando um módulo usando o nível superior awaité avaliado, basicamente retorna uma promessa ao carregador de módulos (como faz uma asyncfunção), que espera até que a promessa seja estabelecida antes de avaliar os corpos de qualquer módulo que dependa dele.

O nível superiorawait passou para o estágio 3, portanto, a resposta para sua pergunta Como posso usar o assíncrono / aguardar no nível superior? é apenas adicionar awaita chamada para 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)

Ou apenas:

const text = await Promise.resolve('Hey there');
console.log('outside: ' + text)

Lembre-se de que ele ainda está disponível apenas no Webpack@v5.0.0-alpha.15 .

Se você estiver usando o TypeScript , ele chegou à 3.8 .

A v8 adicionou suporte nos módulos.

Também é suportado por Deno (como comentado por gonzalo-bahamondez).

A solução real para esse problema é abordá-lo de maneira diferente.

Provavelmente, seu objetivo é algum tipo de inicialização que normalmente ocorre no nível superior de um aplicativo.

A solução é garantir que haja apenas uma única instrução JavaScript no nível superior do seu aplicativo. Se você tiver apenas uma instrução na parte superior do seu aplicativo, poderá usar async / wait em qualquer outro ponto em qualquer lugar (sujeito, é claro, às regras normais de sintaxe)

Dito de outra maneira, envolva todo o seu nível superior em uma função para que ele não seja mais o nível superior e resolva a questão de como executar o assíncrono / aguardar no nível superior de um aplicativo - você não.

É assim que deve ser o nível superior do seu aplicativo:

import {application} from './server'

application();

Para fornecer mais informações sobre as respostas atuais:

O conteúdo de um node.jsarquivo atualmente é concatenado, de maneira semelhante a uma string, para formar um corpo de função.

Por exemplo, se você possui um arquivo test.js:

// Amazing test file!
console.log('Test!');

Em seguida node.js, concatenará secretamente uma função que se parece com:

function(require, __dirname, ... a bunch more top-level properties) {
  // Amazing test file!
  console.log('test!');
}

O principal a ser observado é que a função resultante NÃO é uma função assíncrona. Portanto, você não pode usar o termo awaitdiretamente dentro dele!

Mas digamos que você precise trabalhar com promessas nesse arquivo, então existem dois métodos possíveis:

1. Não use await diretamente dentro da função
2. Não use await

A opção 1 exige a criação de um novo escopo (e ESTE escopo pode ser async, porque temos controle sobre ele):

// Amazing test file!
// Create a new async function (a new scope) and immediately call it!
(async () => {
  await new Promise(...);
  console.log('Test!');
})();

A opção 2 exige que usemos a API de promessa orientada a objetos (o paradigma menos bonito, mas igualmente funcional de trabalhar com promessas)

// Amazing test file!
// Create some sort of promise...
let myPromise = new Promise(...);

// Now use the object-oriented API
myPromise.then(() => console.log('Test!'));

Pessoalmente, espero que, se for viável, o node.js, por padrão, concatene o código em uma asyncfunção. Isso acabaria com essa dor de cabeça.

A espera de nível superior é um recurso do próximo padrão EcmaScript. Atualmente, você pode começar a usá-lo com o TypeScript 3.8 (na versão RC no momento).

Como instalar o TypeScript 3.8

Você pode começar a usar o TypeScript 3.8 instalando-o no npm usando o seguinte comando:

$ npm install typescript@rc

No momento, você precisa adicionar a rctag para instalar a versão mais recente do TypeScript 3.8.

Como main()é executado de forma assíncrona, ele retorna uma promessa. Você precisa obter o resultado no then()método E como os then()retornos também prometem, você deve ligar process.exit()para encerrar o programa.

main()
   .then(
      (text) => { console.log('outside: ' + text) },
      (err)  => { console.log(err) }
   )
   .then(() => { process.exit() } )