await yalnızca eşzamansız işlevde geçerlidir

Bu kodu şuraya yazdım lib/helper.js

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

ve sonra onu başka bir dosyada kullanmayı denedim

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

Bir hata aldım

"await yalnızca eşzamansız işlevde geçerlidir"

Sorun ne?

Hata, atıfta bulunmaktan myfunctionziyade 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();

Ben kullanarak bilinen anti deseni hakkında bilgi vermekten Bu sorunun fırsatı kullanmak awaithangi: return await.

YANLIŞ

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

DOĞRU

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

Ayrıca, return awaitdoğru ve önemli olan özel bir durum olduğunu bilin : (dene / yakala kullanarak)

"Dönüş bekliyor" ile ilgili performans endişeleri var mı?

Bu hatayı aldığımda, "eşzamansız" işlevimin içindeki eşleme işlevine bir çağrı olduğu ortaya çıktı, bu nedenle bu hata iletisi aslında eşleme işlevinin "eşzamansız" olarak işaretlenmemiş olduğunu gösteriyordu. Harita işlevinden "bekle" çağrısını alarak ve beklenen davranışı elde etmenin başka bir yolunu bularak bu sorunu aştım.

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

Kullanmak için await, yürütme bağlamının asyncdoğada olması gerekir

Dediği gibi, her şeyden önce bir göreve executing contextistekli olduğunuz yerinizin doğasını tanımlamanız gerekir await.

Sadece görevinizin yürütüleceği bildirimin asyncönüne koyun .fnasync

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

Açıklama:

Sorunuzda , doğası gereği olan ve paralel olarak çalışacak methodolanı ithal ediyorsunuz asynchronous. Ancak, bu asyncyöntemi yürütmeye çalıştığınız yer , kullanmak execution contextiçin tanımlamanız gereken farklı bir yerdedir .asyncawait

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

Kaputun altında neler olduğunu merak ediyorum

awaitvaat / gelecek / görev döndürme yöntemlerini / işlevlerini tüketir ve asyncbir yöntemi / işlevi await kullanabilecek şekilde işaretler.

Ayrıca aşina iseniz promises, awaitaslında söz / kararlılığının aynı işlemi yapıyor. Bir söz zinciri oluşturmak ve resolvegeri aramada bir sonraki görevi yerine getirmek .

Daha fazla bilgi için başvurabilirsiniz MDN DOCS'a .

Mevcut uygulama async/ awaityalnızca destekler awaitanahtar kelime içindeki asyncfonksiyonları sizin değiştirin startkullanabilirsiniz böylece fonksiyon imza awaitiçeride start.

 var start = async function(a, b) {

 }

İlgilenenler için, üst düzey teklif awaitşu anda Aşama 2'de: https://github.com/tc39/proposal-top-level-await

Aynı sorunu yaşadım ve aşağıdaki kod bloğu aynı hata mesajını veriyordu:

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

Sorun, getCommits () yönteminin zaman uyumsuz olmasıydı, ancak ben ona yine bir Promise tarafından üretilen argüman deposunu geçiriyordum. Bu yüzden, ona async kelimesini şu şekilde eklemem gerekiyordu: async (repo) ve çalışmaya başladı:

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

async / await, vaadi yerine getirme mekanizmasıdır, bunu yapmanın iki yolu

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

            });

veya ilk önce sözün tam olarak doldurulmasını beklemek için beklemeyi kullanabiliriz, bu da reddedildiği veya çözüldüğü anlamına gelir.

Kullandığımız isteyip istemediğim bekliyoruz bir işlev içinde (yerine getirmek için bir söz bekliyor), biz uyumsuz fulfiled için bir söz bekliyor çünkü konteyner işlevi bir zaman uyumsuz işlevi olması gerektiğini zorunludur || mantıklı değil mi?

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 yalnızca eşzamansız işlevde geçerlidir"

Ama neden? "await", eşzamansız bir aramayı açık bir şekilde eşzamanlı aramaya dönüştürür ve bu nedenle, arayan kişi eşzamansız (veya eşzamansız) olamaz - en azından, "bekleme" sırasında yapılan çağrı nedeniyle değil.

Evet, await / async harika bir konseptti, ancak uygulama tamamen bozuk.

Her ne sebeple olursa olsun, await anahtar sözcüğü, yalnızca zaman uyumsuz bir yöntem içinde kullanılabilecek şekilde uygulanmıştır. Bu aslında bir hatadır, ancak buradan başka hiçbir yerde böyle anıldığını görmeyeceksiniz. Bu hatanın düzeltmesi, await anahtar sözcüğünü, çağıran işlevin kendisi eşzamanlı veya eşzamansız olup olmadığına bakılmaksızın, yalnızca zaman uyumsuz bir işlevi ÇAĞIRMAK İÇİN kullanılabilecek şekilde uygulamak olacaktır.

Bu hata nedeniyle, kodunuzun herhangi bir yerinde gerçek bir eşzamansız işlevi çağırmak için await kullanırsanız, TÜM işlevleriniz eşzamansız olarak işaretlenmeli ve işlev çağrılarınızın TÜMÜ await kullanmalıdır.

Bu, esas olarak, tüm uygulamanızdaki tüm işlevlere, çoğu zaman uyumsuz olmayan ve hiçbir zaman eşzamansız olmayacak olan sözlerin ek yükünü eklemeniz gerektiği anlamına gelir.

Gerçekten düşünürseniz, bir işlevde await kullanmak, await anahtar sözcüğünü içeren işlevin ASYNC OLMAMASINI gerektirmelidir - bunun nedeni, await anahtar sözcüğünün, await anahtar sözcüğünün bulunduğu işlevde işlemeyi duraklatmasıdır. Bu işlevde işlem duraklatılırsa, kesinlikle eşzamansız DEĞİLDİR.

Bu nedenle, javascript ve ECMAScript geliştiricilerine - lütfen await / async uygulamasını aşağıdaki gibi düzeltin ...

• await yalnızca CALL async işlevleri için kullanılabilir.
• await, eşzamanlı veya eşzamansız herhangi bir işlevde görünebilir.
• "Await yalnızca eşzamansız işlevde geçerlidir" olan hata iletisini, "await yalnızca eşzamansız işlevleri çağırmak için kullanılabilir" olarak değiştirin.