Combinación de función asíncrona + espera + setTimeout

Estoy tratando de usar las nuevas funciones asíncronas y espero que resolver mi problema ayude a otros en el futuro. Este es mi código que está funcionando:

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

El problema es que mi ciclo while se ejecuta demasiado rápido y el script envía demasiadas solicitudes por segundo a la API de Google. Por lo tanto, me gustaría construir una función de suspensión que retrase la solicitud. Por lo tanto, también podría usar esta función para retrasar otras solicitudes. Si hay otra forma de retrasar la solicitud, hágamelo saber.

De todos modos, este es mi nuevo código que no funciona. La respuesta de la solicitud se devuelve a la función asincrónica anónima dentro de setTimeout, pero simplemente no sé cómo puedo devolver la respuesta a la función de suspensión resp. a la función inicial 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);
  }

Ya he probado algunas opciones: almacenar la respuesta en una variable global y devolverla desde la función de suspensión, devolución de llamada dentro de la función anónima, etc.

Su sleepfunción no funciona porque setTimeoutno (¿todavía?) Devuelve una promesa que podría ser awaiteditada. Tendrá que prometerlo manualmente:

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

Por cierto, para ralentizar su bucle, probablemente no desee usar una sleepfunción que tome una devolución de llamada y la difiera de esta manera. Prefiero recomendar hacer algo como

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

lo que permite que el cálculo parentstome al menos 5 segundos.

Desde el Nodo 7.6 , puede combinar la función de promisifyfunciones desde el módulo 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")
})()

La forma rápida en línea

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

setTimeoutno es una asyncfunción, por lo que no puede usarla con ES7 async-await. Pero podría implementar su sleepfunción utilizando ES6 Promise :

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

Entonces podrá utilizar esta nueva sleepfunción con ES7 async-await:

var fileList = await sleep(listFiles, nextPageToken)

Tenga en cuenta que solo estoy respondiendo su pregunta sobre la combinación de ES7 async / wait con setTimeout, aunque puede que no ayude a resolver su problema al enviar demasiadas solicitudes por segundo.

Actualización: las versiones modernas de node.js tienen una implementación de tiempo de espera asíncrono incorporado , accesible a través de util.promisify helper:

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

Si desea utilizar el mismo tipo de sintaxis, setTimeoutpuede escribir una función auxiliar como esta:

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

Luego puede llamarlo así:

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

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

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

doStuffAsync();

Hice una idea esencial: 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

El siguiente código funciona en Chrome y Firefox y quizás en otros navegadores.

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

Pero en Internet Explorer obtengo un error de sintaxis para "(resolve **=>** setTimeout..."

Hizo una utilidad inspirada en la respuesta de Dave

Básicamente pasado en una donedevolución de llamada para llamar cuando finaliza la operación.

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

Así es como 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);
}

Esta es mi versión con nodejs ahora en 2020 en 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)
    ...
}

Esta es una solución más rápida en una sola línea.

Espero que esto ayude.

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