Combinaison de fonction asynchrone + attente + setTimeout

J'essaie d'utiliser les nouvelles fonctionnalités asynchrones et j'espère que la résolution de mon problème aidera les autres à l'avenir. Voici mon code qui fonctionne:

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

Le problème est que ma boucle while s'exécute trop rapidement et que le script envoie trop de requêtes par seconde à l'API Google. Par conséquent, je voudrais créer une fonction de veille qui retarde la demande. Ainsi, je pourrais également utiliser cette fonction pour retarder d'autres requêtes. S'il existe un autre moyen de retarder la demande, veuillez m'en informer.

Quoi qu'il en soit, c'est mon nouveau code qui ne fonctionne pas. La réponse de la demande est renvoyée à la fonction asynchrone anonyme dans le setTimeout, mais je ne sais pas comment je peux retourner la réponse à la fonction sleep resp. à la fonction asyncGenerator initiale.

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

J'ai déjà essayé quelques options: stockage de la réponse dans une variable globale et retour de la fonction sleep, rappel dans la fonction anonyme, etc.

Votre sleepfonction ne fonctionne pas car setTimeoutne renvoie pas (encore?) Une promesse qui pourrait être awaitéditée. Vous devrez le promettre manuellement:

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

Btw, pour ralentir votre boucle, vous ne voulez probablement pas utiliser une sleepfonction qui prend un rappel et la diffère comme ceci. Je recommanderais plutôt de faire quelque chose comme

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

ce qui permet au calcul de parentsprendre au moins 5 secondes.

Depuis Node 7.6 , vous pouvez combiner la fonction de promisifyfonctions du module utils avec setTimeout().

Node.js

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

Javascript

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

Usage

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

La doublure rapide, en ligne

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

setTimeoutn'est pas une asyncfonction, vous ne pouvez donc pas l'utiliser avec ES7 async-wait. Mais vous pouvez implémenter votre sleepfonction en utilisant ES6 Promise :

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

Ensuite, vous pourrez utiliser cette nouvelle sleepfonction avec ES7 async-wait:

var fileList = await sleep(listFiles, nextPageToken)

Veuillez noter que je ne réponds qu'à votre question sur la combinaison async / ES7 avec ES7 setTimeout, bien que cela ne puisse pas résoudre votre problème avec l'envoi de trop de demandes par seconde.

Mise à jour: les versions modernes de node.js ont une implémentation de délai d'attente asynchrone intégrée , accessible via l' aide util.promisify :

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

Si vous souhaitez utiliser le même type de syntaxe que setTimeoutvous pouvez écrire une fonction d'aide comme celle-ci:

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

Vous pouvez alors l'appeler ainsi:

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

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

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

doStuffAsync();

J'ai fait un résumé: 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

Le code suivant fonctionne dans Chrome et Firefox et peut-être dans d'autres navigateurs.

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

Mais dans Internet Explorer, j'obtiens une erreur de syntaxe pour le "(resolve **=>** setTimeout..."

Faites un utilitaire inspiré de la réponse de Dave

Fondamentalement passé dans un donerappel à appeler lorsque l'opération est terminée.

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

Voici comment je l'utilise:

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

Ceci est ma version avec nodejs maintenant en 2020 dans 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)
    ...
}

Il s'agit d'une solution plus rapide dans une doublure.

J'espère que cela vous aidera.

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