Javascript JS:Async/await不'；Don’我似乎不想在循环中等待结果

我有一个异步映射函数。如果文档不存在，我将在其中创建一组文档。 对于下一个文档，应将第一个创建文档的ID设置为父文档

await Promise.all(data.map(async (o, index) => {
  const key = o.name
  const value = o.value
  const query = { [key]: value }
  const parentID = refID

  console.log(parentID);

  if (parentID) query.parent = parentID

  // Check if document is existing
  let ref = await References.findOne(query)
  refID = ref ? ref._id : undefined

  // If not existing, create it
  if (!refID) {
    const refInserted = await References.insertOne(query)
    refID = refInserted ? refInserted.insertedId : undefined
  }

  console.log(refID)
}))

因此，我希望此日志输出交替使用refID和parentID：

undefined (parentID first run)
yBZWYJcWBoSzx9qwy (refID first run)
yBZWYJcWBoSzx9qwy (parentID second run)
23poGAbg85LCqkcZc (refID second run)
23poGAbg85LCqkcZc (parentID third run)
yBJYzedxftLe2Xm4r (refID third run)
yBJYzedxftLe2Xm4r (parentID fourth run)
PpzjuZ4vfrktNH4ez (refID fourth run)

但我确实明白

undefined
undefined
undefined
undefined
undefined
undefined
yBZWYJcWBoSzx9qwy
23poGAbg85LCqkcZc
yBJYzedxftLe2Xm4r
PpzjuZ4vfrktNH4ez

这表明它不是交替日志输出，而是在两个块中运行，尽管我已经为

insertOne

（使用mongo本机驱动程序）设置了

wait

。很明显，我误解了一些事情：

我想我正在做的是，

map

在本例中与forEach循环相同： 第一次运行后，将提取现有文档的ID或新创建文档的ID（如果未退出）。

---

在第二次运行中，此ID被设置为parentID，以便为第二次创建的文档设置父密钥。

这里的问题是，您不希望使用

承诺。如果您希望同步执行评估，则所有的
。这是因为
Promise.all
将接受一系列承诺，然后允许这些承诺在任何时候都得到解决。相反，将操作包装在异步函数中，然后使用常规循环：

async function processData(data){
    for (var index = data.length - 1; i >= 0; i--) {
        const o = data[index];
        const key = o.name
        const value = o.value
        const query = { [key]: value }
        const parentID = refID

        console.log(parentID);

        if (parentID) query.parent = parentID

        // Check if document is existing
        let ref = await References.findOne(query)
        refID = ref ? ref._id : undefined

        // If not existing, create it
        if (!refID) {
          const refInserted = await References.insertOne(query)
          refID = refInserted ? refInserted.insertedId : undefined
        }

        console.log(refID)
    }
}

这里的问题是，如果希望同步执行评估，则不希望使用
承诺.all
。这是因为
Promise.all
将接受一系列承诺，然后允许这些承诺在任何时候都得到解决。相反，将操作包装在异步函数中，然后使用常规循环：

async function processData(data){
    for (var index = data.length - 1; i >= 0; i--) {
        const o = data[index];
        const key = o.name
        const value = o.value
        const query = { [key]: value }
        const parentID = refID

        console.log(parentID);

        if (parentID) query.parent = parentID

        // Check if document is existing
        let ref = await References.findOne(query)
        refID = ref ? ref._id : undefined

        // If not existing, create it
        if (!refID) {
          const refInserted = await References.insertOne(query)
          refID = refInserted ? refInserted.insertedId : undefined
        }

        console.log(refID)
    }
}

我从你的片段中猜测，事情实际上正在按预期进行。您看到日志输出的原因是，在继续之前，它将为数组的每个项运行map函数的第一个“阶段”（该阶段是下一个等待调用之前的代码）

请参阅此代码段：


var arr=[1,2,3,4,5]
功能计时器（dur）{
返回新承诺（res=>{
设置超时（res，dur）；
});
}
异步函数doStuff（）{
日志（“开始块…”）
等待承诺。全部（arr.map）（异步（x）=>{
console.log（“开始项目的第1阶段：”，x）；
等待定时器（500）；
日志（“第1阶段完成，第2阶段开始，项目：”，x）；
等待定时器（500）；
console.log（“第2阶段完成，项目：”，x）；
}));
日志（“块结束…”）
}
doStuff（）
我从您的代码片段中猜测，事情实际上正在按预期进行。您看到日志输出的原因是，在继续之前，它将为数组的每个项运行map函数的第一个“阶段”（该阶段是下一个等待调用之前的代码）

请参阅此代码段：


var arr=[1,2,3,4,5]
功能计时器（dur）{
返回新承诺（res=>{
设置超时（res，dur）；
});
}
异步函数doStuff（）{
日志（“开始块…”）
等待承诺。全部（arr.map）（异步（x）=>{
console.log（“开始项目的第1阶段：”，x）；
等待定时器（500）；
日志（“第1阶段完成，第2阶段开始，项目：”，x）；
等待定时器（500）；
console.log（“第2阶段完成，项目：”，x）；
}));
日志（“块结束…”）
}
doStuff（）