Zaman uyumsuzluk işlevi + bekleme + set kombinasyonu

Yeni eşzamansız özellikleri kullanmaya çalışıyorum ve umarım problemimi çözmek gelecekte başkalarına yardımcı olacaktır. Bu benim çalışan kod:

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await listFiles(nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

Sorun şu ki, while döngüm çok hızlı çalışıyor ve komut dosyası google API'sına saniyede çok fazla istek gönderiyor. Bu nedenle, talebi geciktiren bir uyku fonksiyonu oluşturmak istiyorum. Böylece bu işlevi diğer istekleri geciktirmek için de kullanabilirim. İsteği ertelemenin başka bir yolu varsa, lütfen bana bildirin.

Her neyse, bu benim yeni kod çalışmıyor. İsteğin yanıtı, setTimeout içinde anonim zaman uyumsuz işlevine döndürülür, ancak uyku işlevine verilen yanıtı nasıl döndürebileceğimi bilmiyorum. başlangıç ​​asyncGenerator işlevine.

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await sleep(listFiles, nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

  async function sleep(fn, par) {
    return await setTimeout(async function() {
      await fn(par);
    }, 3000, fn, par);
  }

Zaten bazı seçenekleri denedim: cevabı global bir değişkende saklamak ve uyku fonksiyonundan geri getirmek, anonim fonksiyon içinde geri arama yapmak vb.

Kişisel sleepçünkü işlevi çalışmıyor setTimeout(henüz?) Olabilir bir söz dönmez awaited. Manuel olarak söz vermeniz gerekecek:

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

Btw, döngünüzü yavaşlatmak için büyük olasılıkla sleepgeri arama alan ve bu şekilde savunan bir işlev kullanmak istemezsiniz . Gibi bir şey yapmayı tercih ederim

while (goOn) {
  // other code
  var [parents] = await Promise.all([
      listFiles(nextPageToken).then(requestParents),
      timeout(5000)
  ]);
  // other code
}

Bu da hesaplamanın parentsen az 5 saniye sürmesini sağlar.

Düğüm 7.6'dan beripromisify , utils modülündeki fonksiyonlar fonksiyonunu aşağıdakilerle birleştirebilirsiniz :setTimeout() .

node.js

const sleep = require('util').promisify(setTimeout)

JavaScript

const sleep = m => new Promise(r => setTimeout(r, m))

kullanım

(async () => {
    console.time("Slept for")
    await sleep(3000)
    console.timeEnd("Slept for")
})()

Hızlı tek astarlı, satır içi

 await new Promise(resolve => setTimeout(resolve, 1000));

setTimeoutbir asyncişlev değildir , bu nedenle ES7 async-await ile kullanamazsınız. Ancak sleepES6 Promise kullanarak işlevinizi uygulayabilirsiniz :

function sleep (fn, par) {
  return new Promise((resolve) => {
    // wait 3s before calling fn(par)
    setTimeout(() => resolve(fn(par)), 3000)
  })
}

Ardından bu yeni sleepişlevi ES7 zaman uyumsuz beklemede kullanabilirsiniz :

var fileList = await sleep(listFiles, nextPageToken)

Lütfen, yalnızca ES7 zaman uyumsuzluğunu / beklemesini birleştirmeyle ilgili sorunuzu yanıtladığımı unutmayınsetTimeout , ancak saniyede çok fazla istek gönderirken sorununuzu çözmenize yardımcı olmayabilir.

Güncelleştirme: Modern node.js sürümlerinde util.promisify yardımcısı aracılığıyla erişilebilen buid-in async zaman aşımı uygulaması var :

const {promisify} = require('util');
const setTimeoutAsync = promisify(setTimeout);

Aynı tür bir sözdizimini kullanmak isterseniz, böyle setTimeoutbir yardımcı işlev yazabilirsiniz:

const setAsyncTimeout = (cb, timeout = 0) => new Promise(resolve => {
    setTimeout(() => {
        cb();
        resolve();
    }, timeout);
});

Daha sonra şöyle diyebilirsiniz:

const doStuffAsync = async () => {
    await setAsyncTimeout(() => {
        // Do stuff
    }, 1000);

    await setAsyncTimeout(() => {
        // Do more stuff
    }, 500);

    await setAsyncTimeout(() => {
        // Do even more stuff
    }, 2000);
};

doStuffAsync();

Bir özledim: https://gist.github.com/DaveBitter/f44889a2a52ad16b6a5129c39444bb57

var testAwait = function () {
    var promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Inside test await');
        }, 1000);
    });
    return promise;
}

var asyncFunction = async function() {
    await testAwait().then((data) => {
        console.log(data);
    })
    return 'hello asyncFunction';
}

asyncFunction().then((data) => {
    console.log(data);
});

//Inside test await
//hello asyncFunction

Aşağıdaki kod Chrome ve Firefox ve diğer tarayıcılarda çalışır.

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

Ancak Internet Explorer'da bir sözdizimi hatası alıyorum. "(resolve **=>** setTimeout..."

Dan esinlenerek bir util Yapılan Dave 'in cevabı

Temel olarak done, işlem bittiğinde aramak için bir geri arama iletilir .

// Function to timeout if a request is taking too long
const setAsyncTimeout = (cb, timeout = 0) => new Promise((resolve, reject) => {
  cb(resolve);
  setTimeout(() => reject('Request is taking too long to response'), timeout);
});

Ben nasıl kullanacağım:

try {
  await setAsyncTimeout(async done => {
    const requestOne = await someService.post(configs);
    const requestTwo = await someService.get(configs);
    const requestThree = await someService.post(configs);
    done();
  }, 5000); // 5 seconds max for this set of operations
}
catch (err) {
  console.error('[Timeout] Unable to complete the operation.', err);
}

Bu 2020 yılında AWS labdalarında nodejs ile benim versiyonum

const sleep = require('util').promisify(setTimeout)

async function f1 (some){
...
}

async function f2 (thing){
...
}

module.exports.someFunction = async event => {
    ...
    await f1(some)
    await sleep(5000)
    await f2(thing)
    ...
}

Bu, tek astarda daha hızlı bir düzeltmedir.

Umarım bu yardımcı olur.

// WAIT FOR 200 MILISECONDS TO GET DATA //
await setTimeout(()=>{}, 200);