Javascript 异步调用上带有承诺的递归

我使用一个外部api作为数据源。该api基于类似分页的类型返回其数据

所以我可以获取第1、2、3页的数据，但我的问题是，我一次需要所有数据，api不支持这一点，所以我自己编写

我已完成实际呼叫代码：

function getTransactionPart(start){
        return new Promise(function(resolve, reject) {

            const options = {
                url: 'myurl?limit=40&start='+start,
                json: true
            };

            let result = {total_transactions : 0, transactions : []};

            request(options, function (error, response, body) {

                if (error) {
                    return reject(result);
                }

                body.data.forEach(function (transaction) {
                        result.transactions.push({
                            timestamp: transaction.timestamp,
                            amount: transaction.amount,
                            confirmed: transaction.confirmed
                        });
                });

                result.total_transactions = body.total

                return resolve(result);
            })
        })
    }

上面的代码返回了我给定的限制的预期结果。另外，当这超过40次时，我会得到一个号码（result.total_transactions），我需要打另一个电话，40次作为开始，等等

我需要组合它的代码：

 function getTransactions(start) {
        return new Promise(function(resolve, reject) {

            getTransactionPart(start).then(result => {
                if(result.total_transactions > 40) {
                    //next call
                } else {
                    // return all?
                }
                console.log(result)
            }).catch(error => {
                console.error(error);
                return r.json({

                })
            });

        })
    }

---

因此，我使用getTransactionPart（0）进行第一次调用，然后方法本身需要组合所有子调用的结果，并按预期返回整个结果。如何使用递归和承诺实现这一点？

如果使用

async

函数并

等待请求，这会更容易：

  async function getTransactions(start) {
    const result = [];
    for(let pos = start; ; pos += 40) {
      const { total_transactions, transactions } = await getTransactionPart(pos);
      result.push(...transactions);

      if(total_transactions < 40) break;
    }
    return result;
 }

异步函数getTransactions（启动）{
常量结果=[]；
对于（让pos=start；；pos+=40）{
const{total_transactions，transactions}=wait getTransactionPart（pos）；
结果。推送（…事务）；
如果（总交易量<40）中断；
}
返回结果；
}

当然，您也可以递归地这样做，但您真的需要这样做吗

async function getTransactions(start) {
  const { total_transactions, transactions } = await getTransactionPart(pos);
  if(total_transactions < 40) 
     return transactions;

  return transactions.concat(await getTransactions(start + 40));
}

异步函数getTransactions（启动）{ const{total_transactions，transactions}=wait getTransactionPart（pos）； if（总交易量<40） 退货交易； returntransactions.concat（wait-getTransactions（start+40））； } 这是一款完美的避孕药！