Javascript 确定何时嵌套FOR循环，以及是否完成了带有一个异步函数调用的语句

我有一个带有嵌套for循环和IF语句的函数，还有一个异步函数调用。结构与此类似：

search(){
    // for loop 1
    for (let i in object){

      // IF statement 1
      if (condition1){

        // for loop 2
        for (let o in object[i]){

          // IF statement 2
          if (condition2){

            // call of an asynchronous function
            this.asyncFunction().then( data => {

              this.result.push(data)

            });
          }
        }
      }
    }
  }

我想在完成所有循环和所有异步函数调用后调用一个函数（比如说

goToNextPage（）

），从而完成我的

this.result

对象

然而，我不知道如何处理这个问题。我尝试使用计数器，以了解最后一个

对象[I]

何时被处理，以及最后一个

对象[I][o]

何时被处理以调用

goToNextPage（）

。但是如果最后一个对象失败了一个if语句，那么这就不能正常工作。然后调用

goToNextPage（）

，而倒数第二个对象的异步函数仍在运行

而且我不能在内部调用

goToNextPage（）

this.asyncFunction().then( data => {
    this.result.push(data)
    // call it here, if last element is reached
});

从那时起，如果最后一个元素不满足其中一个if语句，就不会调用它

我希望我的问题是可以理解的，并且有一个解决办法

---

谢谢你抽出时间

Koleman在官方的爱奥尼亚论坛上完美地回答了这个问题，从而帮助我解决了这个问题：

他的方法是在结构中插入承诺，并使用

Promise.all（承诺）。然后（…）

等待所有承诺得到解决

search(){
   let promises = [];
    // for loop 1
    for (let i in object){
        // IF statement 1
        if (condition1){
            // for loop 2
            for (let o in object[i]){
                // IF statement 2
                if (condition2){
                    let promise = new Promise((resolve, reject) => { 
                        this.asyncFunction().then( data => resolve(data)); 
                    });
                    promises.push(promise); 
                }
            }
        }
    }

    return new Promise((resolve, reject) => {
        if(!promises.length){
            reject('Something went worng!');
        }else{
            Promise.all(promises).then((results) => {
                this.result = this.result.concat(results);
                resolve('We done it!');
            });
        }        
    });         
  }

  search().then(
    successText => {
        console.log(statusText);
        console.log(this.result);
    },
    failText => {
        console.log(failText);
    }
  );

---

科勒曼在官方的爱奥尼亚论坛上完美地回答了这个问题，从而帮助我解决了这个问题：

他的方法是在结构中插入承诺，并使用

Promise.all（承诺）。然后（…）

等待所有承诺得到解决

search(){
   let promises = [];
    // for loop 1
    for (let i in object){
        // IF statement 1
        if (condition1){
            // for loop 2
            for (let o in object[i]){
                // IF statement 2
                if (condition2){
                    let promise = new Promise((resolve, reject) => { 
                        this.asyncFunction().then( data => resolve(data)); 
                    });
                    promises.push(promise); 
                }
            }
        }
    }

    return new Promise((resolve, reject) => {
        if(!promises.length){
            reject('Something went worng!');
        }else{
            Promise.all(promises).then((results) => {
                this.result = this.result.concat(results);
                resolve('We done it!');
            });
        }        
    });         
  }

  search().then(
    successText => {
        console.log(statusText);
        console.log(this.result);
    },
    failText => {
        console.log(failText);
    }
  );

---

一个链接到一个潜在的解决方案总是受欢迎的，但请你这样做，你的同事用户将有一些想法，它是什么，为什么会在那里。始终引用重要链接中最相关的部分，以防无法访问目标站点或永久脱机。考虑到仅仅是一个指向外部站点的链接是一个可能的理由，这就足够公平了。我改进了答案，如建议的，一个链接到一个潜在的解决方案总是受欢迎的，但请让您的同事用户会有一些想法，它是什么，为什么会在那里。始终引用重要链接中最相关的部分，以防无法访问目标站点或永久脱机。考虑到仅仅是一个指向外部站点的链接是一个可能的理由，这就足够公平了。我按照建议改进了答案，