Kombination aus asynchroner Funktion + Warten + SetTimeout

Ich versuche, die neuen asynchronen Funktionen zu verwenden, und hoffe, dass die Lösung meines Problems in Zukunft anderen helfen wird. Dies ist mein Code, der funktioniert:

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

Das Problem ist, dass meine while-Schleife zu schnell ausgeführt wird und das Skript zu viele Anforderungen pro Sekunde an die Google-API sendet. Daher möchte ich eine Sleep-Funktion erstellen, die die Anfrage verzögert. Somit könnte ich diese Funktion auch verwenden, um andere Anfragen zu verzögern. Wenn es eine andere Möglichkeit gibt, die Anfrage zu verzögern, lassen Sie es mich bitte wissen.

Auf jeden Fall ist dies mein neuer Code, der nicht funktioniert. Die Antwort der Anfrage wird an die anonyme asynchrone Funktion innerhalb von setTimeout zurückgegeben, aber ich weiß einfach nicht, wie ich die Antwort an die Sleep-Funktion bzw. die Sleep-Funktion zurückgeben kann. zur anfänglichen asyncGenerator-Funktion.

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

Ich habe bereits einige Optionen ausprobiert: Speichern der Antwort in einer globalen Variablen und Zurückgeben von der Sleep-Funktion, Rückruf innerhalb der anonymen Funktion usw.

Ihre sleepFunktion funktioniert nicht, weil setTimeout(noch?) Kein Versprechen zurückgegeben wird, das bearbeitet werden könnte await. Sie müssen es manuell versprechen:

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

Übrigens, um Ihre Schleife zu verlangsamen, möchten Sie wahrscheinlich keine sleepFunktion verwenden, die einen Rückruf entgegennimmt und ihn so verzögert. Ich würde eher empfehlen, so etwas zu tun

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

Dadurch kann die Berechnung von parentsmindestens 5 Sekunden dauern.

Seit Knoten 7.6 können Sie die promisifyFunktionsfunktion aus dem Utils-Modul mit kombinieren setTimeout().

Node.js

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

Javascript

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

Verwendung

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

Der schnelle Einzeiler inline

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

setTimeoutist keine asyncFunktion, daher können Sie sie nicht mit ES7 async-await verwenden. Sie können Ihre sleepFunktion jedoch mit ES6 Promise implementieren :

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

Dann können Sie diese neue sleepFunktion mit ES7 async-await verwenden:

var fileList = await sleep(listFiles, nextPageToken)

Bitte beachten Sie, dass ich nur Ihre Frage zum Kombinieren von ES7 async / await mit beantworte setTimeout, obwohl dies möglicherweise nicht zur Lösung Ihres Problems beim Senden zu vieler Anfragen pro Sekunde beiträgt .

Update: Moderne node.js-Versionen verfügen über eine integrierte asynchrone Timeout-Implementierung, auf die über den Hilfsprogramm util.promisify zugegriffen werden kann :

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

Wenn Sie dieselbe Syntax verwenden möchten, wie setTimeoutSie eine Hilfsfunktion wie diese schreiben können:

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

Sie können es dann so nennen:

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

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

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

doStuffAsync();

Ich habe eine Zusammenfassung erstellt: 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

Der folgende Code funktioniert in Chrome und Firefox und möglicherweise in anderen Browsern.

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

Aber in Internet Explorer bekomme ich einen Syntaxfehler für die "(resolve **=>** setTimeout..."

Aus Dave 's Antwort inspiriert

Grundsätzlich wird ein doneRückruf übergeben, um nach Abschluss des Vorgangs aufzurufen.

// 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);
});

So benutze ich es:

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

Dies ist meine Version mit NodeJS jetzt im Jahr 2020 in AWS Labdas

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

Dies ist eine schnellere Lösung für Einzeiler.

Hoffe das wird helfen.

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