如何重复调用异步 function 直到指定超时？

Question

I want to keep calling asnchronous api requests repeatedly until it exceeds specified time. Using async-retry we can only specify retrycount and interval, we wanted to specify even timeout in the parameter. Can you just suggest a way?

// try calling apiMethod 3 times, waiting 200 ms between each retry
async.retry({times: 3, interval: 200}, apiMethod, function(err, result) {
    // do something with the result
});

Answer 1

Here is what you want:

 const scheduleTrigger = (futureDate) => { const timeMS = new Date(futureDate) - new Date(); return new Promise((res, ref) => { if (timeMS > 0) { setTimeout(() => { res(); }, timeMS); } else { rej(); } }) } //const futureDate = '2020-07-23T20:53:12'; // or const futureDate = new Date(); futureDate.setSeconds(futureDate.getSeconds() + 5); console.log('now'); scheduleTrigger(futureDate).then(_ => { console.log('future date reached'); // start whatever you want stopFlag = false; }).catch(_ => { // the date provided was in the past }); const wait = (ms = 2000) => { return new Promise(res => { setTimeout(_ => { res(); }, ms); }) } const asyncFn = _ => Promise.resolve('foo').then(x => console.log(x)); let stopFlag = true; (async () => { while (stopFlag) { await asyncFn(); await wait(); } })();

Answer 2

So you want to keep retrying for as long as its within a certain timeout? How about this:

// Allow retry until the timer runs out
let retry = true;
const timeout = setTimeout(() => {
  // Set retry to false to disabled retrying
  retry = false;

  // Can also build in a cancel here
}, 10000); // 10 second timeout

const retryingCall = () => {
  apiMethod()
    .then(response => {
      // Optionally clear the timeout
      clearTimeout(timeout);
    })
    .catch(() => {
      // If retry is still true, retry this function again
      if (retry) {
        retryingCall();
      }
    });
};

Answer 3

You can achieve what you want with this function:

const retryWithTimeout = ({ timeout, ...retryOptions}, apiMethod, callback) => {
  let timedout = false;
  const handle = setTimeout(
    () => (timedout = true, callback(new Error('timeout'))),
    timeout
  );

  return async.retry(
    retryOptions, 
    innerCallback => timedout || apiMethod(innerCallback),
    (err, result) => timedout || (clearTimeout(handle), callback(err, result))
  )
};

It has the advantage of allowing you to use the functionality of async.retry , as you apparently want, and also allows the timeout to take place even when what exceeds the timeout is the apiMethod itself, not the waiting time.

Usage example:

retryWithTimeout( 
  {timeout: 305, times: 4, interval: 100}, 
  (callback) => { callback('some api error'); },
  (err, result) => console.log('result', err, result)
)