Combinazione di funzione asincrona + await + setTimeout

Sto cercando di utilizzare le nuove funzionalità asincrone e spero che risolvere il mio problema possa aiutare gli altri in futuro. Questo è il mio codice che funziona:

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

Il problema è che il mio ciclo while è troppo veloce e lo script invia troppe richieste al secondo all'API di google. Pertanto, vorrei creare una funzione sleep che ritardi la richiesta. Quindi potrei anche usare questa funzione per ritardare altre richieste. Se esiste un altro modo per ritardare la richiesta, per favore fatemelo sapere.

Comunque, questo è il mio nuovo codice che non funziona. La risposta della richiesta viene restituita alla funzione asincrona anonima all'interno di setTimeout, ma non so come restituire la risposta alla funzione sleep. alla funzione iniziale asyncGenerator.

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

Ho già provato alcune opzioni: memorizzare la risposta in una variabile globale e restituirla dalla funzione sleep, richiamata all'interno della funzione anonima, ecc.

La tua sleepfunzione non funziona perché setTimeoutnon (ancora?) Restituisce una promessa che potrebbe essere modificata await. Dovrai promuoverlo manualmente:

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

A proposito, per rallentare il tuo loop probabilmente non vorrai usare una sleepfunzione che accetta un callback e lo difende in questo modo. Preferirei raccomandare di fare qualcosa del genere

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

che consente al calcolo di parentsrichiedere almeno 5 secondi.

Dal Nodo 7.6 , è possibile combinare la funzione promisifyfunzioni dal modulo utils con setTimeout().

Node.js

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

Javascript

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

uso

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

Il modo rapido in una linea, in linea

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

setTimeoutnon è una asyncfunzione, quindi non è possibile utilizzarlo con ES7 async-waitit. Ma potresti implementare la tua sleepfunzione usando ES6 Promise :

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

Quindi sarai in grado di utilizzare questa nuova sleepfunzione con ES7 async-await:

var fileList = await sleep(listFiles, nextPageToken)

Per favore, nota che sto solo rispondendo alla tua domanda sulla combinazione di ES7 asincrono / wait setTimeout, anche se potrebbe non aiutare a risolvere il tuo problema con l'invio di troppe richieste al secondo.

Aggiornamento: le moderne versioni di node.js hanno un'implementazione di timeout asincrono integrata , accessibile tramite l' utilità util.promisify :

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

Se desideri utilizzare lo stesso tipo di sintassi, setTimeoutpuoi scrivere una funzione di supporto come questa:

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

Puoi quindi chiamarlo così:

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

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

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

doStuffAsync();

Ho fatto un'idea: 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

Il seguente codice funziona in Chrome e Firefox e forse in altri browser.

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

Ma in Internet Explorer ricevo un errore di sintassi per il "(resolve **=>** setTimeout..."

Fatto un util ispirato da Dave 's risposta

Fondamentalmente passato in un donecallback per chiamare al termine dell'operazione.

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

Ecco come lo uso:

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

Questa è la mia versione con nodejs ora nel 2020 in labdas AWS

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

Questa è una soluzione più rapida in una riga.

Spero che questo possa aiutare.

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