awaitは非同期関数でのみ有効です

私はこのコードを書いた lib/helper.js

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

それから私はそれを別のファイルで使用しようとしました

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

エラーが発生しました

「待機は非同期関数でのみ有効です」

どうした？

エラーはに関するものではなく、に関するmyfunctionもの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();

私が使用して、既知のアンチパターンについてあなたにアドバイスするために、この質問の機会を利用await：ありますreturn await。

違う

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');
})();

正しい

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');
})();

また、return await正しく重要な特別なケースがあることを知ってください：（try / catchを使用）

「返品待ち」でパフォーマンスの問題はありますか？

このエラーが発生したとき、「async」関数内でmap関数が呼び出されたことが判明したため、このエラーメッセージは実際には「async」としてマークされていないmap関数を参照していました。この問題を回避するには、map関数から "await"呼び出しを取り、期待される動作を得る別の方法を考え出しました。

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

を使用するにはawait、その実行コンテキストがasync自然である必要があります

それが言ったように、あなたは何よりも先にタスクにexecuting context進んで進んでいるあなたの性質を定義する必要がありますawait。

ただ、置くasync前にfn、あなたのここで宣言asyncタスクが実行されます。

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')
}

説明：

あなたの質問では、あなたは本質的にあり、並行して実行されるをインポートしてmethodいますasynchronous。しかし、そのasyncメソッドを実行しようとしている場所は、使用execution contextするために定義asyncする必要がある別の内部にありますawait。

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

フードの下で何が起こっているのだろうか

awaitpromise / future / task-returningメソッド/関数asyncを使用し、awaitを使用できるようにメソッド/関数をマークします。

また、に精通しているpromises場合awaitは、実際に同じプロセスで約束/解決を行っています。promiseのチェーンを作成し、resolveコールバックで次のタスクを実行します。

詳細については、MDN DOCSを参照してください。

現在の実装では、async/ awaitのみサポートawaitのキーワード内部async機能は、あなたの変更startに使用できるように、関数のシグネチャをawait内側にstart。

 var start = async function(a, b) {

 }

興味のある方のために、トップレベルの提案awaitは現在ステージ2にあります：https : //github.com/tc39/proposal-top-level-await

私は同じ問題を抱えていて、次のコードブロックが同じエラーメッセージを出していました：

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

問題は、メソッドgetCommits（）が非同期でしたが、Promiseによって生成された引数repoを渡していたことです。そのため、async（repo）のようにasyncという単語を追加する必要があり、それが機能し始めました。

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

async / awaitはpromiseを処理するメカニズムであり、2つの方法で実行できます

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

            });

または、awaitを使用して、最初に完全に提出するという約束を待つことができます。つまり、拒否または解決されます。

関数内でawait（フルフィルメントのプロミスの待機）を使用したい場合、非同期でプロフィルされるのプロミスを待機しているため、コンテナー関数は非同期関数でなければなりません|| 理にかなっていますか？

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'は非同期呼び出しを明示的に同期呼び出しに変換するため、呼び出し元は非同期（または非同期）にすることができません。少なくとも、 'await'で行われた呼び出しのためではありません。

はい、await / asyncは素晴らしいコンセプトでしたが、実装は完全に壊れています。

何らかの理由で、awaitキーワードは、非同期メソッド内でのみ使用できるように実装されています。これは実際にはバグですが、ここではそのように呼ばれることはありません。このバグの修正は、呼び出し関数自体が同期か非同期かに関係なく、非同期関数を呼び出すためにのみ使用できるようにawaitキーワードを実装することです。

このバグのため、awaitを使用してコードのどこかで実際の非同期関数を呼び出す場合、すべての関数を非同期としてマークし、すべての関数呼び出しでawaitを使用する必要があります。

これは本質的に、アプリケーション全体のすべての関数にpromiseのオーバーヘッドを追加する必要があることを意味します。そのほとんどは非同期ではなく、非同期になることもありません。

実際に考えてみると、関数でawaitを使用するには、awaitキーワードを含む関数が非同期になる必要があります。これは、awaitキーワードが、awaitキーワードが見つかった関数で処理を一時停止するためです。その関数での処理が一時停止している場合は、非同期ではありません。

それで、javascriptとECMAScriptの開発者に-次のようにawait / async実装を修正してください...

• awaitは非同期関数の呼び出しにのみ使用できます。
• awaitは、同期または非同期のあらゆる種類の関数で使用できます。
• エラーメッセージを「awaitは非同期関数でのみ有効」から「awaitは非同期関数の呼び出しにのみ使用できます」に変更します。