Javascript 运行多个递归承诺并在请求时中断

我正在开发一个LED条动画工具，它允许用户选择多个可以同时运行的效果。每一种效果都是（蓝鸟）的承诺。有一个

run（）

方法可以设置LED条的颜色

所有承诺都使用

delay

方法以固定的FPS运行

run(mode) {
    return this.setStripColor(this.color).delay(1 / this.fps).then(() => { this.run(1 / this.fps) })
}

// example of an effect
rainbowSweep() {
    // .. 
    // magical unicorn code
    // ..
    return Promise.resolve().delay(1 / this.fps).then(() => {
        this.rainbowSweep()
    })

app.rainbowSweep()
app.run()

是否有某种类型的数据结构可以用于切换递归承诺？换句话说，我如何发出信号（递归承诺）停止递归

我正在考虑一个包含所有承诺的数组。

---

但是，当递归承诺不再在数组中时，我不知道如何打破/解决它。我可以在返回前检查promise本身是否在数组中，但我希望有一种更优雅的方法。

这是一个使用异步生成器的示例，可以使用

return

或

break

停止迭代

const o={
价值：新地图，
完成：错误，
异步*gen（…道具）{
而（！this.done）{
if（this.value.size&&！this.done）{
试一试{
for（此.value的常量[key，val]{
//yield*[{key，value:await Promise.all（[].concat（val）.map（prop=>typeof prop==“function”？prop（）：prop））。然后（values=>{this.value.delete（key）；return values}）。catch（err=>{console.log（err）；return{error:[key，err]}）}）；
//当'this.done'设置为'true'时，不会立即中断`
对于wait（const value of[].concat（val）.map（prop=>Promise.resolve（typeof prop===“function”？prop（）：prop）。然后（prop=>{console.log（“prop:”，prop）；return prop}，err=>{
console.error（“捕获等待：”，err）；返回err；
}))) {
日志（“值：”，值）；
if（key！==未定义和值！==未定义和值！&&！o.done）
收益率*[{
键、值
}];
}
此.value.delete（键）；
}
}捕获（错误）{
错误（“异步捕获：”，错误）；
抛出错误
}
}否则{
//收益等待`在${new Date（）}'没有值'；
this.done=true；
打破
}
}
}
};
（异步（）=>{
设n=0；
让我们抓住，将军；
试一试{
gen=o.gen（）；
next=新代理（o.value.set.bind（o.value））{
应用（目标、参数、参数）{
//console.log（args）；
如果（！o.done&&args.length）{
Reflect.apply（target，null，args）；
返回gen.next（）.catch（错误=>{
失误
})
};
如果（！args.length&&！o.done）返回gen.next（）.catch（err=>Promise.reject（err））；
如果（完成）{
catch=“我们到此为止”；
返回gen.throw（catch.catch（err=>{throw err}）
};
}
});
等待下一个（n，Promise.resolve（0））.catch（err=>{
失误
})
.那么(({
价值，完成
})=>console.log（值，完成））；
等待下一步（++n，Promise.resolve（1））
.catch（错误=>{
失误
})
.那么(({
价值，完成
})=>console.log（值，完成））；
等待下一步（++n，[Promise.resolve（2）]）
.catch（错误=>{
失误
})
.那么(({
价值，完成
})=>console.log（值，完成））；
等待下一步（++n，[（）=>新承诺（r=>setTimeout（r，2000，3））
，（）=>新承诺（（拒绝）=>设置超时（6000，4））
，（）=>新承诺（r=>setTimeout（r，4000，5））
]
)
.catch（错误=>{
失误
})
.那么(({
价值，完成
})=>console.log（值，完成））；
//o.done=true；//停止生成器
while（o.value.size&&！o.value.done）{
等待下一个
.catch（错误=>{
失误
}).那么(({
价值，完成
}) => {
日志（值，完成，o.value.size）；
返回
})
}
}捕获（e）{
让信息=等待；
如果（消息==“我们到此结束”）{
控制台错误（“错误：”，消息）；
}否则{
console.error（“捕获时捕获：”，消息）；
抛出新错误（消息）
}
}最后{
控制台日志（gen）；
如果（捕获）抛出新错误（捕获）
返回{done:o.done，value:o.value.size}
}
})()
.catch（err=>{console.error（“确定捕获：”，err）；返回err}）
.then（done=>console.log（“done:，done））；
异步函数*gen（n）{
设i=1；
while（true）{
让curr=收益率等待新的承诺（r=>setTimeout（r，1000，i））；
如果（当前）{
i*=货币；
};
i*=25；
如果（i>500*500）断裂；
}
}
异步函数读取（n）{
常数g=gen（n）；
//while（wait g.next（）.then（{value，done}）=>{console.log（value，done）；return！done}）；
等待g.next（）.then（（{value，done}）=>{console.log（value，done）；返回！done}）；
等待g.next（100）.then（{value，done}）=>{console.log（value，done）；return！done}）；
等待g.next（）.then（（{value，done}）=>{console.log（value，done）；返回！done}）；
等待g.next（）.then（（{value，done}）=>{console.log（value，done）；返回！done}）；
}
阅读（5）

我对你的问题的解释可能有点离谱，但我认为你正在尝试在所有递归完成后解决最初的承诺。如果这是您要问的，那么您可以将初始承诺传递给每个递归调用

在我的示例中，我会使用您的示例代码，但是您缺少函数的右括号，因此我不确定它应该是什么样子。。下面是这个概念的一个通用示例

var递归\u计数器=0；
函数MyRecursivePromiseFunction（prm）{
返回新承诺（完成=>{
计数器++；
prm=prm | |完成；
如果（递归计数器>=5）prm（）；
else-myrecursivepromisesfunction（prm）；
});
}
MyRecursivePromiseFunction（）。然后（（）=>{
控制台日志（递归计数器）
let RUNNING =
  true

const main = async (elem, color = Color ()) =>
  RUNNING
    ? delay (color, FPS)
        .then (effect (color => setElemColor (elem, color)))
        .then (color => main (elem, stepColor (color)))
    : color

const Color = (r = 128, g = 128, b = 128) =>
  ({ r, g, b })

const stepColor = ({ r, g, b }, step = 8) =>
  b < 255
    ? Color (r, g, b + step)
    : g < 255
      ? Color (r, g + step, 0)
      : r < 255
        ? Color (r + step, 0, 0)
        : Color (0, 0, 0)

const setElemColor = (elem, { r, g, b }) =>
  elem.style.backgroundColor = `rgb(${r}, ${g}, ${b})`

const c = new Color () // { r: 128, g: 128, b: 128 }
setpColor (c)          // { r: 128, g: 128, b: 136 }

const delay = (x, ms) =>
  new Promise (r => setTimeout (r, ms, x))

const effect = f => x =>
  (f (x), x)

const FPS =
  1000 / 30

main (document.querySelector('#main'))
  .then (console.log, console.error)
  // => { Color r: 136, g: 8, b: 40 }

// stop after 5 seconds
setTimeout (() => RUNNING = false, 5000)