Javascript 仅当函数已运行10次时，才转至下一步

我有这个功能：

function setIntervalX(callback, delay, repetitions): Promise<any> {

  let promises = [];

  var x = 0;
  var intervalID = window.setInterval(function () {
  callback();
    if (++x === repetitions) {
      window.clearInterval(intervalID);
      promises.push(new Promise((resolve, reject) => {});
    }
   }, delay);
  return Promise.all(promises);
}

---

我觉得我这样做的方式很丑陋，可以做得更好。有什么建议吗？

除非你需要单独的承诺（除了在

承诺中，你从不使用上面的承诺。所有的
），只要使用一个承诺：

function setIntervalX(callback, delay, repetitions): Promise<any> {
    return new Promise(resolve => {
        let x = 0;
        let intervalID = window.setInterval(function () {
            callback();
            if (++x === repetitions) {
                window.clearInterval(intervalID);
                resolve();
            }
        }, delay);
    });
}

函数setIntervalX（回调、延迟、重复）：承诺{
返回新承诺（解决=>{
设x=0；
让intervalID=window.setInterval（函数（）{
回调（）；
如果（++x==重复次数）{
窗口。clearInterval（intervalID）；
解决（）；
}
}，延误）；
});
}
您也标记了RxJS，因此我将抛出一个Rx解决方案

function setIntervalX(callback, delay, repetitions): Observable<any> {
  //Emit an event every delay
  return Rx.Observable.interval(delay)
    //Only accept a certain number of events
    .take(repetitions)
    // Process the callback each time
    .do(() => callback())
    // Convert the result into a promise
    .toPromise();
}

setIntervalX(() => {
  //logic here  
}, 1000, 10)
.then(() => {                
  expect(something).toBe(anotherThing);
});

函数setIntervalX（回调、延迟、重复）：可观察{
//每个延迟发出一个事件
返回接收可观测间隔（延迟）
//只接受一定数量的事件
.进行（重复）
//每次处理回调
.do（（）=>callback（））
//将结果转化为承诺
.toPromise（）；
}
setIntervalX（（）=>{
//这里的逻辑
}, 1000, 10)
.然后（（）=>{
期望（某物）成为（另一物）；
});
您想要更优雅的解决方案，这是怎么回事：


var wait=ms=>newpromise（resolve=>setTimeout（resolve，ms））；
让setIntervalX=（cb、延迟、重复）=>
all（数组（reps）.fill（）.map（（n，i）=>wait（delay*（i+1））.then（cb））；
//演示：
让test=（）=>Promise.resolve（），然后（（）=>（console.log（“test”），“！”）；
setIntervalX（test，1000，10）.then（results=>console.log（results.join（“”））好的，我重新格式化了，你现在能帮我吗：）？恕我直言，但请看上面的内容。你真的会称之为“一致且可读”的格式吗<代码>回调
在第一个代码块中未对齐，这会产生误导；第一个块在其他方面仍然具有不一致的缩进特征；对第二个代码块说得越少越好。让你的文章和代码清晰明了，并证明你花了时间这样做，可以提高你获得好答案的机会。如果这是一个测试，为什么你要以1秒的间隔将它们隔开，而不是背靠背地运行它们？您的问题还不清楚
回调
是否会返回承诺，即有效地表示异步操作，以及执行所需时间是否少于一秒钟（意味着测试按顺序执行），或者更多（它们最终并发执行，即并行执行）。澄清这一点可能会使问题变得更好。你所说的“通话已结束”是什么意思？如果您只是想在第10次呼叫被触发后继续，那么
setTimeout（大约10000）
似乎就足够了。很好，但它仍然不够优雅，可以做得更好吗？@JerzyGruszka：除了删除不必要的
窗口。
在计时器功能上，我不确定您还会做什么。@T.J.Crowder如果callback（）抛出或返回被拒绝的承诺，则无法正确传播错误。@jib：我只是在解决实际问题，没有做代码复查。
function setIntervalX(callback, delay, repetitions): Observable<any> {
  //Emit an event every delay
  return Rx.Observable.interval(delay)
    //Only accept a certain number of events
    .take(repetitions)
    // Process the callback each time
    .do(() => callback())
    // Convert the result into a promise
    .toPromise();
}

setIntervalX(() => {
  //logic here  
}, 1000, 10)
.then(() => {                
  expect(something).toBe(anotherThing);
});