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

Estoy tratando de utilizar las nuevas funciones asincrónicas 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 crear 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 asíncrona 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 asyncGenerator inicial.

  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 probé 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 setTimeout(¿todavía?) No devuelve una promesa que podría awaiteditarse. Deberá promisificarlo 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 ciclo, probablemente no quiera 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 de parentstome al menos 5 segundos.

Desde el Nodo 7.6 , puede combinar la función de promisifyfunciones del 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 de una sola línea, 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 puede implementar su sleepfunción usando 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 / await con setTimeout, aunque es posible que no ayude a resolver su problema con el envío de demasiadas solicitudes por segundo.

Actualización: las versiones modernas de node.js tienen una implementación de tiempo de espera asincrónica incorporada , accesible a través del ayudante util.promisify :

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

A continuación, 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 esencia: 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

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

Actualización 2020

Puede await setTimeoutcon Node.js 15 o superior:

const timersPromises = require('timers/promises');

(async () => {
  const result = await timersPromises.setTimeout(2000, 'resolved')
  // Executed after 2 seconds
  console.log(result); // "resolved"
})()

API de Timers Promises: https://nodejs.org/api/timers.html#timers_timers_promises_api (biblioteca ya construida en Node)

Nota: Estabilidad: 1 - No se recomienda el uso de la función en entornos de producción.

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 el "(resolve **=>** setTimeout..."

Hizo una utilidad inspirada en la respuesta de Dave

Básicamente se pasa 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);
}

await setTimeout(()=>{}, 200);

Funcionará si su versión de nodo es 15 o superior.