Question

假设我有一个功能fetch(id)。

我会在随机时间任意调用它。

但是我希望每个连续的呼叫只在前一个呼叫结束后才能运行。

说异步任务需要4秒钟，我拨打fetch 3次。那么总时间应该是12秒。

我可以创建一个数组，并且在每个调用集的承诺下都会进行下一步。

但有什么方法可以实现这一目标。

Answer 1

我想我明白了

//First my example function which could be anything but should return promise which would be queued

function example(n) {
    return new Promise((res, rej) => {
        setTimeout(()=> {
            console.log(n);
            res();
        }, 1000);
    });
}


//now solution

function debounce(func) {

    let p = Promise.resolve();

    return function(x){
        p = p.then(() => func(x));
    }
}


//usage

d = debounce(example);
d(1);d(2);d(3);d(4);d(5);d(6);d(1);

Answer 2

你可以在没有数组的情况下链接Promise，只需存储指向最后一个Promise的指针

// async payload function
// returns a promise
function f(x) {
  console.log(`call f(${x})`);
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(`resolve f(${x})`);
      resolve();
    }, 2000);
  });
}

// wrapper to call function `f` sequentially
// stores pointer to the last Promise in closure
const g = (function(){
  let lastPromise = Promise.resolve();
  return function(arg){
    lastPromise = lastPromise.then(() => f(arg));
  }
})();

// generate random calls of function function `g`
for (let i = 0; i < 5; i++) {
  setTimeout(() => g(i), Math.random() * 100);
}

Answer 3

我猜你可以使用async.io库。或者，每次要调用函数时，将函数本身推入数组中。上一个函数完成后，检查是否还有一些函数要在数组中调用。

创建一个函数，无论多少次调用仅在第一次异步调用完成时运行？

3 个答案: