Javascript 带结束承诺的等待函数

我试图从firebase获取一个集合，然后调用一个函数来插入数据。问题是在比较函数结束之前调用了插入数据

这是我遵循的指南：

1-获取游戏输入，并创建一个包含要推荐的视频的阵列

2-从用户处获取已推荐的视频

3-将视频与阵列进行比较，以排除重复的视频

4-继续执行下一个函数，将阵列插入firebase

问题是，对于第4步，我需要完成第3步。但事实并非如此。有没有关于如何解决这个问题的建议

export const generateRecommendationsFromGame = (participantID) => {
  var newRec = [];
  let userRef = firebase.firestore().collection("users").doc(participantID);


  //1 Game inputs
  return firebase.firestore().collection("inputGame").where("user", "==", userRef).onSnapshot({}, function(querySnapshot) {
    querySnapshot.forEach(function(doc) {
      let consagua = doc.data().consagua;
      let enfart = doc.data().enfartamento;
      let mastig = doc.data().mastigacao;
      let mexdorm = doc.data().mexerdormir;
      let emoc = doc.data().emocoes;

      //13
      //V2.3.2
      if (Number(consagua) >= 3) {
        newRec.push('V2.3.2');
      }
      //15
      //V3.1
      if (Number(enfart) >= 25) {
        newRec.push('V3.1');
      }
      //16
      //V3.2
      if (Number(mastig) >= 40) {
        newRec.push('V3.2');
      }
      //17
      //V3.3
      //18
      //V3.4
      if (Number(mexdorm) >= 3) {
        newRec.push('V3.3');
        newRec.push('V3.4');
      }
      //19
      //V3.5
      if (Number(emoc) >= 2) {
        newRec.push('V3.5');
      }


      //2 - User Videos
      return firebase.firestore().collection("recommendedVideo").where("user", "==", userRef).get().then(result2 => {
        result2.forEach(doc2 => {

          //3 - Get video ref to compate to Array
          var videoFef = doc2.data().video.id;
          firebase.firestore().collection("videos").doc(videoFef).get().then(
            function(doc2) {
              if (doc2.exists) {
                var sequence = doc2.data().sequenceNumberID;
                for (var i = 0; i < newRec.length; i++) {
                  if (String(sequence) == String(newRec[i])) {
                    var index = newRec.indexOf(newRec[i]);
                    if (index > -1) {
                      newRec.splice(index, 1);
                    }
                  }
                }
              } else alert("Não existe doc videos");
            }
          )
        });
      }).then(() => {
         insertData(newRec);
      })
    });
  })
};

export const generaterecommissionsfromgame=（participantID）=>{
var newRec=[]；
让userRef=firebase.firestore（）.collection（“users”）.doc（participantID）；
//1游戏输入
返回firebase.firestore（）.collection（“inputGame”）.where（“user”，“==”，userRef）.onSnapshot（{}，函数（querySnapshot）{
querySnapshot.forEach（函数（doc）{
设consagua=doc.data（）.consagua；
设enfart=doc.data（）.enfartamento；
设mastig=doc.data（）.mastigacao；
让mexform=doc.data（）.mexerdormir；
设emoc=doc.data（）.emocoes；
//13
//V2.3.2
如果（数量（consagua）>=3）{
新记录推送（“V2.3.2”）；
}
//15
//V3.1
如果（数字（enfart）>=25）{
newRec.push（'V3.1'）；
}
//16
//V3.2
如果（数量（mastig）>=40）{
newRec.push（'V3.2'）；
}
//17
//V3.3
//18
//V3.4
如果（数字（mexform）>=3）{
newRec.push（'V3.3'）；
newRec.push（'V3.4'）；
}
//19
//V3.5
如果（编号（emoc）>=2）{
newRec.push（'V3.5'）；
}
//2-用户视频
返回firebase.firestore（）.collection（“recommendedVideo”）.where（“user”，“==”，userRef.get（）。然后（result2=>{
结果2.forEach（doc2=>{
//3-获取视频参考以兼容阵列
var videoFef=doc2.data（）.video.id；
firebase.firestore（）.collection（“videos”）.doc（videoFef.get（）。然后(
功能（doc2）{
如果（doc2.exists）{
var sequence=doc2.data（）.sequenceNumberID；
对于（变量i=0；i-1）{
新接头（索引1）；
}
}
}
}else alert（“Não existe doc视频”）；
}
)
});
}).然后（（）=>{
插入数据（newRec）；
})
});
})
};

然后，在比较视频并排除重复的视频后，我想调用函数在Firebase上插入视频

export const insertData= (arr) => {   
  var newRec = arr.split(',');
  for (var i = 0; i < newRec.length; i++) {
    var ref = newRec[i];
    firebase.firestore().collection("videos").where("sequenceNumberID", "==", ref.toString()).onSnapshot(function (querySnapshot) {
      querySnapshot.forEach(function (doc) {
        firebase.firestore().collection("recommendedVideo").add({
          seen: false,
          user: firebase.firestore().collection('users').doc(participantID),
          video: firebase.firestore().collection('videos').doc(doc.id)
        }).catch(function (error) {
          alert(error);
        })
      });
    });
  }
}

export const insertData=（arr）=>{
var newRec=arr.split（'，'）；
对于（变量i=0；i

您需要对每个

doc2

进行异步查询，然后在所有查询完成后继续执行

insertData

。正确的工具是

Promise.all

，它接受一个承诺数组，并在数组中的所有承诺都被解析后解析。因此，将每个

doc2

映射到一个承诺

除了

Promise.all

，还可以使用

async

/

wait

来大大降低成本

请注意，您正在对

forEach

中的

doc2

变量进行阴影（复制），这很容易引起混淆-最好将其命名为其他名称（例如

doc3

）：

使

querySnapshot.forEach

异步：

querySnapshot.forEach(async (doc) => {

然后：

//2 - User Videos
const result2 = await firebase.firestore().collection("recommendedVideo").where("user", "==", userRef).get();
await Promise.all(result2.map(async (doc2) => {
  //3 - Get video ref to compate to Array
  const videoFef = doc2.data().video.id;
  const doc3 = await firebase.firestore().collection("videos").doc(videoFef).get();
  if (!doc3.exists) {
    alert("Não existe doc videos");
    return;
  }
  var sequence = doc3.data().sequenceNumberID;
  for (var i = 0; i < newRec.length; i++) {
    if (String(sequence) !== String(newRec[i])) return;
    var index = newRec.indexOf(newRec[i]);
    if (index > -1) newRec.splice(index, 1);
  }
}));
// end of Promise.all
insertData(newRec);

//2-用户视频
const result2=await firebase.firestore（）.collection（“recommendedVideo”）.where（“user”、“==”、userRef.get（）；
等待承诺.all（result2.map）（异步（doc2）=>{
//3-获取视频参考以兼容阵列
const videoFef=doc2.data（）.video.id；
const doc3=wait firebase.firestore（）.collection（“videos”）.doc（videoFef.get（）；
如果（！doc3.存在）{
警报（“Não existe doc视频”）；
返回；
}
var sequence=doc3.data（）.sequenceNumberID；
对于（变量i=0；i-1）新接头（索引，1）；
}
}));
//承诺的结束
插入数据（newRec）；

以下是我如何解决这个问题的

        var reads = [];

        await firebase.firestore().collection("recommendedVideo").where("user", "==", userRef).onSnapshot({}, function (querySnapshot) {
            querySnapshot.forEach(async doc => {
                reads.push(doc);
            })
            return Promise.all(reads.map(async (doc1) => {
                //3 - Get video ref to compate to Array
                const videoFef = doc1.data().video.id;
                const doc3 = await firebase.firestore().collection("videos").doc(videoFef).get();
                if (!doc3.exists) {
                    alert("Não exisste doc videos");
                    return;
                }

                var sequence = doc3.data().sequenceNumberID;
                for (var i = 0; i < newRec.length; i++) {
                    if (String(sequence) == String(newRec[i])) {
                        var index = newRec.indexOf(newRec[i]);
                        if (index > -1) {
                            newRec.splice(index, 1);
                        }
                    }
                }
            })).then(function() {
                insertData(newRec, participantID);
            });
        });

var reads=[]；
等待firebase.firestore（）.collection（“recommendedVideo”）.where（“user”，“==”，userRef）.onSnapshot（{}，函数（querySnapshot）{
querySnapshot.forEach（异步文档=>{
读。推（doc）；
})
返回Promise.all（reads.map）（异步（doc1）=>{
//3-获取视频参考以兼容阵列
const videoFef=doc1.data（）.video.id；
const doc3=wait firebase.firestore（）.collection（“videos”）.doc（videoFef.get（）；
如果（！doc3.存在）{
警报（“Não exisste doc视频”）；
返回；
}
var sequence=doc3.data（）.sequenceNumberID；
对于（变量i=0；i-1）{