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

假设我有一个函数

fetch（id）

我会在随机的时间任意地称呼它

但我希望每个连续的调用只在前一个调用完成后运行

假设异步任务需要4秒钟，我调用

fetch

3次。那么总时间应该是12秒

我可以做一个数组，每次调用集合时，我都会保证通过下一个队列

但有什么方法可以做到这一点。

我想你们可以使用图书馆。 或者，每次要调用函数时，将函数本身推入一个数组中。上一个函数完成后，检查数组中是否还有一些函数需要调用。

我想您可以使用库。 或者，每次要调用函数时，将函数本身推入一个数组中。当上一个函数完成后，检查数组中是否还有一些函数需要调用。

我想我知道了

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

我想我明白了

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

---

您可以在不使用数组的情况下链接承诺，只需存储指向最后一个承诺的指针

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

//异步负载函数
//回报承诺
函数f（x）{
log（`callf（${x}）`）；
返回新承诺（（解决）=>{
设置超时（（）=>{
log（`resolve f（${x}）`）；
解决（）；
}, 2000);
});
}
//按顺序调用函数'f'的包装器
//存储指向闭包中最后一个承诺的指针
常量g=（函数（）{
让lastPromise=Promise.resolve（）；
返回函数（arg）{
lastPromise=lastPromise.then（（）=>f（arg））；
}
})();
//生成函数`g的随机调用`
for（设i=0；i<5；i++）{
setTimeout（（）=>g（i），Math.random（）*100）；
}

您可以在不使用数组的情况下链接承诺，只需存储指向最后一个承诺的指针即可

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

//异步负载函数
//回报承诺
函数f（x）{
log（`callf（${x}）`）；
返回新承诺（（解决）=>{
设置超时（（）=>{
log（`resolve f（${x}）`）；
解决（）；
}, 2000);
});
}
//按顺序调用函数'f'的包装器
//存储指向闭包中最后一个承诺的指针
常量g=（函数（）{
让lastPromise=Promise.resolve（）；
返回函数（arg）{
lastPromise=lastPromise.then（（）=>f（arg））；
}
})();
//生成函数`g的随机调用`
for（设i=0；i<5；i++）{
setTimeout（（）=>g（i），Math.random（）*100）；
}

是的，承诺队列是一种很好的方法。是的，承诺队列是一种很好的方法。如何使用async.js？这里有很多功能是绝对没有用的。你怎么使用async.js呢？这里有一大堆功能绝对没有用。哇，我找到了同一个解决方案，你可以使用Promise.resolve（），它将立即运行，因此不需要条件哇，我找到了同一个解决方案，你可以使用Promise.resolve（），它将立即运行，因此不需要条件