await działa tylko w funkcji asynchronicznej

Napisałem ten kod w lib/helper.js

var myfunction = async function(x,y) {
   ....
   reutrn [variableA, variableB]
}
exports.myfunction = myfunction;

a potem próbowałem użyć go w innym pliku

 var helper = require('./helper.js');   
 var start = function(a,b){
     ....
     const result = await helper.myfunction('test','test');
 }
 exports.start = start;

Wystąpił błąd

„await działa tylko w funkcji asynchronicznej”

Jaki jest problem?

Błąd nie odnosi się do, myfunctionale do start.

async function start() {
   ....

   const result = await helper.myfunction('test', 'test');
}

// My function
const myfunction = async function(x, y) {
  return [
    x,
    y,
  ];
}

// Start function
const start = async function(a, b) {
  const result = await myfunction('test', 'test');
  
  console.log(result);
}

// Call start
start();

Używam okazji tej kwestii doradzić o znanej strukturze z wykorzystaniem anty awaitktóry jest: return await.

ŹLE

async function myfunction() {
  console.log('Inside of myfunction');
}

// Here we wait for the myfunction to finish
// and then returns a promise that'll be waited for aswell
// It's useless to wait the myfunction to finish before to return
// we can simply returns a promise that will be resolved later

// useless async here
async function start() {
  // useless await here
  return await myfunction();
}

// Call start
(async() => {
  console.log('before start');

  await start();
  
  console.log('after start');
})();

POPRAWNY

async function myfunction() {
  console.log('Inside of myfunction');
}

// Here we wait for the myfunction to finish
// and then returns a promise that'll be waited for aswell
// It's useless to wait the myfunction to finish before to return
// we can simply returns a promise that will be resolved later

// Also point that we don't use async keyword on the function because
// we can simply returns the promise returned by myfunction
function start() {
  return myfunction();
}

// Call start
(async() => {
  console.log('before start');

  await start();
  
  console.log('after start');
})();

Pamiętaj też, że istnieje specjalny przypadek, w którym return awaitjest poprawny i ważny: (używając try / catch)

Czy istnieją problemy z wydajnością w przypadku polecenia „return await”?

Kiedy pojawił się ten błąd, okazało się, że wywołałem funkcję map w mojej funkcji „async”, więc ten komunikat o błędzie w rzeczywistości odnosi się do funkcji mapy, która nie została oznaczona jako „async”. Omówiłem ten problem, usuwając wywołanie „await” z funkcji mapy i wymyślając inny sposób uzyskania oczekiwanego zachowania.

var myfunction = async function(x,y) {
    ....
    someArray.map(someVariable => { // <- This was the function giving the error
        return await someFunction(someVariable);
    });
}

Aby użyć await, kontekst wykonywania musi mieć asynccharakter

Jak zostało powiedziane, musisz najpierw zdefiniować naturę swojego executing contextmiejsca, w którym jesteś gotów wykonać awaitzadanie.

Wystarczy wstawić asyncprzed fndeklaracją, w której Twoje asynczadanie zostanie wykonane.

var start = async function(a, b) { 
  // Your async task will execute with await
  await foo()
  console.log('I will execute after foo get either resolved/rejected')
}

Wyjaśnienie:

W swoim pytaniu importujesz to, methodco ma asynchronousnaturę i będzie wykonywane równolegle. Ale miejsce, w którym próbujesz wykonać tę asyncmetodę, znajduje się wewnątrz innej, execution contextktórą musisz zdefiniować, asyncaby użyć await.

 var helper = require('./helper.js');   
 var start = async function(a,b){
     ....
     const result = await helper.myfunction('test','test');
 }
 exports.start = start;

Zastanawiasz się, co się dzieje pod maską

awaitzużywa metody / funkcje zwracające obietnicę / przyszłość / zadania i asyncoznacza metodę / funkcję jako zdolną do używania await.

Również, jeśli jesteś zaznajomiony promises, awaitfaktycznie robi ten sam proces obietnicy / postanowienia. Tworzenie łańcucha obietnic i wykonywanie następnego zadania w resolveoddzwonieniu.

Więcej informacji można znaleźć w MDN DOCS .

Bieżąca implementacja async/ awaitobsługuje tylko awaitsłowo kluczowe wewnątrz asyncfunkcji Zmień startsygnaturę funkcji, aby można było używać jej awaitwewnątrz start.

 var start = async function(a, b) {

 }

Dla zainteresowanych propozycja na najwyższy poziom awaitjest obecnie na etapie 2: https://github.com/tc39/proposal-top-level-await

Miałem ten sam problem i następujący blok kodu podawał ten sam komunikat o błędzie:

repositories.forEach( repo => {
        const commits = await getCommits(repo);
        displayCommit(commits);
});

Problem polega na tym, że metoda getCommits () była asynchroniczna, ale przekazałem jej argument repo, który również został utworzony przez Promise. Musiałem więc dodać do niego słowo async w ten sposób: async (repo) i zaczęło działać:

repositories.forEach( async(repo) => {
        const commits = await getCommits(repo);
        displayCommit(commits);
});

async / await to mechanizm obsługi obietnicy, możemy to zrobić na dwa sposoby

functionWhichReturnsPromise()
            .then(result => {
                console.log(result);
            })
            .cathc(err => {
                console.log(result);

            });

lub możemy użyć await, aby najpierw poczekać na pełne wypełnienie obietnicy, co oznacza, że ​​zostanie odrzucona lub rozwiązana.

Teraz, jeśli chcemy użyć await (oczekiwania na spełnienie obietnicy) wewnątrz funkcji, obowiązkowe jest, aby funkcja kontenera była funkcją asynchroniczną, ponieważ czekamy na asynchroniczne spełnienie obietnicy || ma sens, prawda ?.

async function getRecipesAw(){
            const IDs = await getIds; // returns promise
            const recipe = await getRecipe(IDs[2]); // returns promise
            return recipe; // returning a promise
        }

        getRecipesAw().then(result=>{
            console.log(result);
        }).catch(error=>{
            console.log(error);
        });

„await działa tylko w funkcji asynchronicznej”

Ale dlaczego? „await” jawnie zamienia wywołanie asynchroniczne w wywołanie synchroniczne, a zatem obiekt wywołujący nie może być asynchroniczny (lub asynchroniczny) - przynajmniej nie dlatego, że wywołanie jest wykonywane w trybie „await”.

Tak, await / async był świetnym pomysłem, ale implementacja jest całkowicie zepsuta.

Z jakiegoś powodu słowo kluczowe await zostało zaimplementowane w taki sposób, że może być używane tylko w ramach metody asynchronicznej. W rzeczywistości jest to błąd, chociaż nie zobaczysz go jako takiego nigdzie poza tym tutaj. Rozwiązaniem tego błędu byłoby zaimplementowanie słowa kluczowego await w taki sposób, że może być używane tylko DO WYWOŁANIA funkcji asynchronicznej, niezależnie od tego, czy funkcja wywołująca jest sama w sobie synchroniczna, czy asynchroniczna.

Z powodu tego błędu, jeśli używasz await do wywołania prawdziwej funkcji asynchronicznej gdzieś w kodzie, WSZYSTKIE twoje funkcje muszą być oznaczone jako async, a WSZYSTKIE wywołania funkcji muszą używać await.

Zasadniczo oznacza to, że musisz dodać narzut obietnic do wszystkich funkcji w całej aplikacji, z których większość nie jest i nigdy nie będzie asynchroniczna.

Jeśli naprawdę się nad tym zastanowisz, użycie await w funkcji powinno wymagać, aby funkcja zawierająca słowo kluczowe await NIE BYŁA ASYNC - dzieje się tak, ponieważ słowo kluczowe await wstrzyma przetwarzanie w funkcji, w której znajduje się słowo kluczowe await. Jeśli przetwarzanie w tej funkcji jest wstrzymane, to zdecydowanie NIE jest asynchroniczne.

Tak więc, dla twórców javascript i ECMAScript - napraw implementację await / async w następujący sposób ...

• await można używać tylko do wywoływania funkcji asynchronicznych.
• await może pojawić się w dowolnej funkcji, synchronicznej lub asynchronicznej.
• Zmień komunikat o błędzie z „await działa tylko w funkcji asynchronicznej” na „await może być używany tylko do wywoływania funkcji asynchronicznych”.