Połączenie funkcji asynchronicznej + oczekiwanie + setTimeout

Próbuję korzystać z nowych funkcji asynchronicznych i mam nadzieję, że rozwiązanie mojego problemu pomoże innym w przyszłości. To jest mój kod, który działa:

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

Problem polega na tym, że moja pętla while działa zbyt szybko, a skrypt wysyła zbyt wiele żądań na sekundę do interfejsu API Google. Dlatego chciałbym zbudować funkcję uśpienia, która opóźnia żądanie. W ten sposób mógłbym również użyć tej funkcji do opóźnienia innych żądań. Jeśli istnieje inny sposób opóźnienia żądania, daj mi znać.

W każdym razie to mój nowy kod, który nie działa. Odpowiedź żądania jest zwracana do anonimowej funkcji asynchronicznej w ramach setTimeout, ale po prostu nie wiem, jak mogę zwrócić odpowiedź na funkcję uśpienia lub. do początkowej funkcji 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);
  }

Próbowałem już kilka opcji: przechowywanie odpowiedzi w zmiennej globalnej i zwrócenie jej z funkcji uśpienia, wywołanie zwrotne w funkcji anonimowej itp.

Twoja sleepfunkcja nie działa, ponieważ setTimeout(jeszcze?) Nie zwraca obietnicy, którą można by awaitedytować. Musisz ręcznie obiecać:

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

Przy okazji, aby spowolnić pętlę, prawdopodobnie nie chcesz używać sleepfunkcji, która odbiera wywołanie zwrotne i odkłada go w ten sposób. Wolałbym raczej zrobić coś takiego

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

co pozwala na obliczenie parentsco najmniej 5 sekund.

Od Węzła 7.6 możesz łączyć funkcje promisifyfunkcji z modułu utils z setTimeout().

Node.js

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

JavaScript

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

Stosowanie

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

Szybki, liniowy, liniowy sposób

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

setTimeoutnie jest asyncfunkcją, więc nie można jej używać z asynchronicznym oczekiwaniem na ES7. Ale możesz zaimplementować swoją sleepfunkcję za pomocą ES6 Promise :

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

Następnie będziesz mógł użyć tej nowej sleepfunkcji z asynchronicznym oczekiwaniem na ES7:

var fileList = await sleep(listFiles, nextPageToken)

Pamiętaj , że odpowiadam tylko na twoje pytanie dotyczące połączenia asynchronicznego / oczekującego ES7 z setTimeout, choć może nie pomóc rozwiązać problemu z wysyłaniem zbyt wielu żądań na sekundę.

Aktualizacja: Nowoczesne wersje node.js mają wbudowaną implementację limitu czasu asynchronicznego dostępu, dostępną za pośrednictwem pomocnika util.promisify :

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

Jeśli chcesz użyć tego samego rodzaju składni, jak setTimeoutmożesz napisać funkcję pomocniczą w następujący sposób:

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

Możesz to tak nazwać:

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

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

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

doStuffAsync();

Zrobiłem sedno: 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

Poniższy kod działa w Chrome i Firefox i być może w innych przeglądarkach.

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

Ale w Internet Explorerze pojawia się błąd składni dla "(resolve **=>** setTimeout..."

Popełnił util inspirowane z Dave „s odpowiedź

Zasadniczo przekazano w donewywołaniu zwrotnym, aby zadzwonić po zakończeniu operacji.

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

Tak to wykorzystuję:

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

To jest moja wersja z nodejs teraz w 2020 roku w 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)
    ...
}

Jest to szybsze rozwiązanie w jednej linijce.

Mam nadzieję, że to pomoże.

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