Utilizzo di await al di fuori di una funzione async

Stavo tentando di concatenare due funzioni asincrone, perché la prima aveva un parametro di ritorno condizionale che causava l'esecuzione della seconda o l'uscita dal modulo. Tuttavia, ho riscontrato un comportamento strano che non riesco a trovare nelle specifiche.

async function isInLobby() {
    //promise.all([chained methods here])
    let exit = false;
    if (someCondition) exit = true;
}

Questo è uno snippet imbastardito del mio codice (puoi vedere l'intero ambito qui ), che controlla semplicemente se un giocatore è già in una lobby, ma è irrilevante.

Successivamente abbiamo questa funzione asincrona.

async function countPlayer() {
    const keyLength = await scardAsync(game);
    return keyLength;
}

Questa funzione non deve essere eseguita se exit === true.

Ho provato a fare

const inLobby = await isInLobby();

Questo speravo attendesse i risultati, quindi posso usarlo inLobbyper eseguire in modo condizionale countPlayer, tuttavia ho ricevuto un errore di tipo senza dettagli specifici.

Perché non puoi awaituna asyncfunzione al di fuori dell'ambito della funzione? So che è una promessa di zucchero, quindi deve essere incatenato thenma perché dentro countPlayerposso aspettare un'altra promessa, ma fuori non posso await isInLobby?

Il livello superiore awaitnon è supportato. Ci sono alcune discussioni da parte del comitato per gli standard sul motivo per cui questo è, come questo problema di GitHub .

C'è anche un pensiero su GitHub sul perché l'attesa di alto livello sia una cattiva idea. In particolare, suggerisce che se hai un codice come questo:

// data.js
const data = await fetch( '/data.json' );
export default data;

Ora qualsiasi file importato data.jsnon verrà eseguito fino al completamento del recupero, quindi tutto il caricamento del modulo è ora bloccato. Ciò rende molto difficile ragionare sull'ordine dei moduli dell'app, poiché siamo abituati a eseguire Javascript di primo livello in modo sincrono e prevedibile. Se ciò fosse consentito, sapere quando una funzione viene definita diventa complicato.

La mia prospettiva è che è una cattiva pratica che il tuo modulo abbia effetti collaterali semplicemente caricandolo. Ciò significa che qualsiasi consumatore del tuo modulo otterrà effetti collaterali semplicemente richiedendo il tuo modulo. Questo limita fortemente dove può essere usato il tuo modulo. Un livello superiore awaitprobabilmente significa che stai leggendo da qualche API o chiamando un servizio al momento del caricamento. Invece dovresti semplicemente esportare le funzioni asincrone che i consumatori possono utilizzare al proprio ritmo.

Ovviamente c'è sempre questo:

(async () => {
    await ...

    // all of the script.... 

})();
// nothing else

Questo crea una funzione rapida con async in cui puoi usare wait. Ti evita la necessità di creare una funzione asincrona, il che è fantastico! // crediti Silve2611

Ancora meglio è inserire un punto e virgola aggiuntivo davanti al blocco di codice

;(async () => {
    await ...
})();

Ciò impedisce al formattatore automatico (ad esempio in vscode) di spostare la prima parentesi alla fine della riga precedente.

Il problema può essere dimostrato nel seguente esempio:

const add = x => y => x+y
const increment = add(1)
(async () => {
    await ...
})();

Senza il punto e virgola, questo verrà riformattato come:

const add = x => y => x+y
const increment = add(1)(async () => {
  await Promise(1)
})()

il che ovviamente è sbagliato perché assegna la funzione asincrona come yparametro e cerca di chiamare una funzione dal risultato (che in realtà è una stringa strana '1async () => {...}')

A partire da Node.js 14.3.0, l' attesa di primo livello è supportata.

Bandiera richiesto: --experimental-top-level-await.

Ulteriori dettagli: https://v8.dev/features/top-level-await

puoi fare il massimo attendo dal dattiloscritto 3.8
https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#-top-level-await
Dal post:
Questo perché in precedenza in JavaScript (insieme alla maggior parte degli altri linguaggi con una funzionalità simile), await era consentito solo all'interno del corpo di una funzione asincrona. Tuttavia, con il livello più alto di await, possiamo usare await al livello più alto di un modulo.

const response = await fetch("...");
const greeting = await response.text();
console.log(greeting);

// Make sure we're a module
export {};

Nota che c'è una sottigliezza: il primo livello di attesa funziona solo al livello più alto di un modulo e i file sono considerati moduli solo quando TypeScript trova un'importazione o un'esportazione. In alcuni casi di base, potresti dover scrivere export {} come un boilerplate per assicurarti di questo.

Il massimo livello di attesa potrebbe non funzionare in tutti gli ambienti in cui potresti aspettarti a questo punto. Al momento, puoi usare il primo livello di attesa solo quando l'opzione del compilatore di destinazione è es2017 o superiore e il modulo è esnext o system. Il supporto in diversi ambienti e bundler può essere limitato o può richiedere l'abilitazione del supporto sperimentale.