Javascript https请求在循环中，在节点发出最后一个请求后调用函数

假设我多次调用

https

a来检索数据，并且我想在最后一个请求结束时调用函数

formatjsontologe

。除了检查数组的最后一个元素外，是否有其他方法可以确定该请求何时结束

let sheetsArray = []

function sheetsAsJsonById (ids) {
  for (let i = 0; i < ids.length; i++) {
    const queryUrl = `sheets.html`

    https
      .get(queryUrl, res => {
        let stream = []
        res
      .on('data', function (data) {
        stream.push(data)
      })
      .on('end', function () {
        let data = Buffer.concat(stream)

        data = JSON.parse(data)
        sheetArrays.push(data['values'])

        formatJsonToLocale(sheetsArray) // <----- call this one after last request
      })
  })
  .on('error', err => {
    console.error(`Error in response: ${err}`)
  })
 }
}

let sheetsArray=[]
函数表SASJSONBYID（ids）{
for（设i=0；i{
让流=[]
物件
.on（'data'，函数（data）{
stream.push（数据）
})
.on（'end'，函数（）{
让数据=Buffer.concat（流）
data=JSON.parse（数据）
sheetArrays.push（数据['values']）
formatJsonToLocale（sheetsArray）//{
console.error（`error in response:${err}`）
})
}
}

当我在函数外部调用

formatJsonToLocale

时，我会遇到一个问题，即前一个函数可能无法完成，因为

https

异步处理内容

---

有关如何处理此问题的任何建议？

Wrap

https。在承诺中获取

，该承诺在

结束

事件时解决，并拒绝任何错误。现在，您可以等待承诺，并在for循环完成后调用函数

let sheetsArray = []

function sheetsAsJsonById(ids) {
    for (let i = 0; i < ids.length; i++) {
        const queryUrl = `sheets.html`
        await new Promise((resolve, reject) => {
            https
                .get(queryUrl, res => {
                    let stream = []
                    res
                        .on('data', function(data) {
                            stream.push(data)
                        })
                        .on('end', function() {
                            let data = Buffer.concat(stream)

                            data = JSON.parse(data)
                            sheetsArray.push(data['values'])

                            resolve();
                        })
                })
                .on('error', err => {
                    reject(err);
                })
        })

    }
    formatJsonToLocale(sheetsArray)
}

let sheetsArray=[]
函数表SASJSONBYID（ids）{
for（设i=0；i{
https
.get（queryUrl，res=>{
让流=[]
物件
.on（'data'，函数（data）{
stream.push（数据）
})
.on（'end'，function（）{
让数据=Buffer.concat（流）
data=JSON.parse（数据）
sheetsArray.push（数据['values']）
解决（）；
})
})
.on（'error'，err=>{
拒绝（错误）；
})
})
}
formatJsonToLocale（sheetsArray）
}

您需要跟踪在for循环中执行的异步代码（

https.get

）的执行情况。这可以通过以下承诺实现：

let sheetsArray = []

function sheetsAsJsonById (ids) {

    let promises = []

    for (let i = 0; i < ids.length; i++) {
        const queryUrl = `sheets.html`
        promises.push(makeHTTPRequest(queryUrl))
    }

    Promise.all(promises).then((sheetArrays) => {
        formatJsonToLocale(sheetsArray)
    })
}



const makeHTTPRequest = (url) => {
    return new Promise((resolve, reject) => {
        https
          .get(url, res => {
            let stream = []
            res
          .on('data', function (data) {
            stream.push(data)
          })
          .on('end', function () {
            let data = Buffer.concat(stream)

            data = JSON.parse(data)
            resolve(data)
          })
          .on('error', err => {
            console.error(`Error in response: ${err}`)
          })
    })
}

let sheetsArray=[]
函数表SASJSONBYID（ids）{
让承诺=[]
for（设i=0；i{
formatJsonToLocale（sheetsArray）
})
}
const makeHTTPRequest=（url）=>{
返回新承诺（（解决、拒绝）=>{
https
.get（url，res=>{
让流=[]
物件
.on（'data'，函数（data）{
stream.push（数据）
})
.on（'end'，函数（）{
让数据=Buffer.concat（流）
data=JSON.parse（数据）
解析（数据）
})
.on（'error'，err=>{
console.error（`error in response:${err}`）
})
})
}

---

如果您想坚持回调，可以使用节点模块的

async.each

函数。

可能有更好的方法，但您不能只执行

If（sheetsArray.length==ids.length）

？请注意，您有

sheetsArray=[]

但是你正在推动

sheetArrays

。编程中的拼写问题TTP/s循环请求缺乏思考。这不是一个好的实现。@CarlosEspinoza说吧，我洗耳恭听：）谢谢你的回答。在你的承诺中你指的是

url

不是

查询url

我想谢谢你的帮助！