Javascript 承诺链中的类递归行为

我目前正在努力实现对特定Promiseblock的递归

我将代码抽象为以下内容，以提供一个示例：

function x(){
    return new Promise((resolve, reject)=>{
    return resolve(2)
  })
}

var testvar = 0

x()
.then(result => {
    // simulating mongodb request which returns another promise
    return new Promise(resolve => {resolve()})
})
.then(result => { // BLOCK START
    // simulating another operation
  testvar += 1
  return new Promise(resolve => {resolve()})
})
.then(result => {
    // some other operations

  if(testvar < 2){
   // RERUN PROMISE FROM BLOCK START
   console.log("pls recurse")
  }else{
    // some other operation
    return new Promise(resolve => {resolve()})
  }
  // BLOCK END
})
.then(result => {
    // continue
  console.log("foo")
})
.catch(err => console.log(err))



// classic approach

function y(){
    // something
    // Operation 1
    // Operation 2
  if(x != 1 ){
    y() // recurse
  }else{
    // continue
  }
}

函数x（）{
返回新承诺（（解决、拒绝）=>{
返回解析（2）
})
}
var testvar=0
x（）
。然后（结果=>{
//模拟返回另一个承诺的mongodb请求
返回新承诺（resolve=>{resolve（）}）
})
。然后（结果=>{//块开始
//模拟另一个操作
testvar+=1
返回新承诺（resolve=>{resolve（）}）
})
。然后（结果=>{
//其他一些行动
if（testvar<2）{
//从块开始重新运行承诺
控制台日志（“请递归”）
}否则{
//其他手术
返回新承诺（resolve=>{resolve（）}）
}
//块端
})
。然后（结果=>{
//继续
console.log（“foo”）
})
.catch（err=>console.log（err））
//经典方法
函数y（）{
//某物
//操作1
//行动2
如果（x！=1）{
y（）//递归
}否则{
//继续
}
}

现在我想让这段代码一个接一个地运行Promisechain，直到最后一个（记录“foo”的那个）。除非testvar小于2，否则我希望再次执行“//BLOCK START”中的函数，直到testvar大于或等于2

我依赖于这个基于promisebuild的构建，因为我正在对助手库和mongodb进行一些异步函数调用，后者返回承诺

代码也可以在测试环境中进行测试

如果有什么不清楚的地方，请随意提问——我会很乐意尝试精确地回答我的问题。

---

谢谢您的帮助。

与普通递归函数没有太大区别。将代码移动到

运行块

函数中，在

if

条件下调用

返回运行块（result）或返回您已解决的承诺：

function x() {
  return new Promise((resolve, reject) => {
    return resolve(2)
  })
}

var testvar = 0

function runBlock(result) {

  testvar += 1
  return new Promise(resolve => {
      resolve()
    })
    .then(result => {
      // some other operations

      if (testvar < 2) {
        console.log('testvar < 2');
        // RERUN PROMISE FROM BLOCK START
        return runBlock(result);
      } else {
        console.log('testvar >= 2');
        // some other operation
        return new Promise(resolve => {
          resolve()
        })
      }
      // BLOCK END
    })
}


x()
  .then(result => {
    // simulating mongodb request which returns another promise
    return new Promise(resolve => {
      resolve()
    })
  })
  .then(runBlock)
  .then(result => {
    // continue
    console.log("foo")
  })
  .catch(err => console.log(err))


function a(a) {
  return new Promise(resolve => {
    resolve(a)
  })
}

// classic approach

function y() {
  // something
  // Operation 1
  // Operation 2
  if (x != 1) {
    y() // recurse
  } else {
    // continue
  }
}

函数x（）{
返回新承诺（（解决、拒绝）=>{
返回解析（2）
})
}
var testvar=0
函数运行块（结果）{
testvar+=1
返回新承诺（解决=>{
解决（）
})
。然后（结果=>{
//其他一些行动
if（testvar<2）{
log（'testvar<2'）；
//从块开始重新运行承诺
返回runBlock（结果）；
}否则{
log（'testvar>=2'）；
//其他手术
返回新承诺（解决=>{
解决（）
})
}
//块端
})
}
x（）
。然后（结果=>{
//模拟返回另一个承诺的mongodb请求
返回新承诺（解决=>{
解决（）
})
})
.then（运行块）
。然后（结果=>{
//继续
console.log（“foo”）
})
.catch（err=>console.log（err））
职能a（a）{
返回新承诺（解决=>{
决议（a）
})
}
//经典方法
函数y（）{
//某物
//操作1
//行动2
如果（x！=1）{
y（）//递归
}否则{
//继续
}
}
与普通递归函数没有太大区别。将代码移动到
运行块
函数中，在
if
条件下调用
返回运行块（result）或返回您已解决的承诺：

function x() {
  return new Promise((resolve, reject) => {
    return resolve(2)
  })
}

var testvar = 0

function runBlock(result) {

  testvar += 1
  return new Promise(resolve => {
      resolve()
    })
    .then(result => {
      // some other operations

      if (testvar < 2) {
        console.log('testvar < 2');
        // RERUN PROMISE FROM BLOCK START
        return runBlock(result);
      } else {
        console.log('testvar >= 2');
        // some other operation
        return new Promise(resolve => {
          resolve()
        })
      }
      // BLOCK END
    })
}


x()
  .then(result => {
    // simulating mongodb request which returns another promise
    return new Promise(resolve => {
      resolve()
    })
  })
  .then(runBlock)
  .then(result => {
    // continue
    console.log("foo")
  })
  .catch(err => console.log(err))


function a(a) {
  return new Promise(resolve => {
    resolve(a)
  })
}

// classic approach

function y() {
  // something
  // Operation 1
  // Operation 2
  if (x != 1) {
    y() // recurse
  } else {
    // continue
  }
}

函数x（）{
返回新承诺（（解决、拒绝）=>{
返回解析（2）
})
}
var testvar=0
函数运行块（结果）{
testvar+=1
返回新承诺（解决=>{
解决（）
})
。然后（结果=>{
//其他一些行动
if（testvar<2）{
log（'testvar<2'）；
//从块开始重新运行承诺
返回runBlock（结果）；
}否则{
log（'testvar>=2'）；
//其他手术
返回新承诺（解决=>{
解决（）
})
}
//块端
})
}
x（）
。然后（结果=>{
//模拟返回另一个承诺的mongodb请求
返回新承诺（解决=>{
解决（）
})
})
.then（运行块）
。然后（结果=>{
//继续
console.log（“foo”）
})
.catch（err=>console.log（err））
职能a（a）{
返回新承诺（解决=>{
决议（a）
})
}
//经典方法
函数y（）{
//某物
//操作1
//行动2
如果（x！=1）{
y（）//递归
}否则{
//继续
}
}
这可能是@t.niese在承诺中递归的简化版本。它的可行性如下


var pr=Promise.resolve（1），
履行=v=>Promise.resolve（v*=2）
.然后（v=>v>100？“foo”：（console.log（v），fulFillment（v））；
pr.then（履行）
.then（v=>console.log（v））
.catch（e=>console.log（e））这可能是@t.niese在承诺中递归的简化版本。它的可行性如下


var pr=Promise.resolve（1），
履行=v=>Promise.resolve（v*=2）
.然后（v=>v>100？“foo”：（console.log（v），fulFillment（v））；
pr.then（履行）
.then（v=>console.log（v））
.catch（e=>console.log（e））函数
。我看不到你代码中承诺链的任何部分。我知道我不知道该如何实现它。我猜我是瞎了眼，因为我专注于承诺：）对于递归，你总是需要一个
函数。我看不到你代码中承诺链的任何部分。我知道我不知道该如何实现它。我猜我是瞎了眼，因为我专注于承诺：）这很好，但我在
then
块中看到了很多不必要的承诺。你为什么不直接返回结果，因为
然后
无论如何都会返回一个承诺。@Redu我相信OP只是为真实代码创建了一些占位符来说明问题，所以我没有更改它们，只是将代码转换为递归调用。这很好，但我看到了很多不必要的承诺