Node.js中MongoDB循环操作仅最后一条生效，如何让循环等待操作完成？

这个坑我之前踩过好几次！你遇到的问题本质是同步循环和异步数据库操作的冲突，再加上var声明变量的作用域问题，导致最后只有循环的最后一次操作看起来生效了。

问题根源拆解 #

1. 异步操作不等待：你的for循环是同步执行的，会一次性把所有数据库请求都发出去，但MongoDB的操作（find/insertOne/updateOne）都是异步的，循环不会等前一个操作完成就直接跑到下一次迭代了。
2. 变量作用域污染：你用var声明的变量（比如unique、Info、EID）是函数级作用域，循环里所有迭代共享同一个变量引用。等异步回调触发时，循环已经跑完了，所有回调拿到的都是最后一次迭代的变量值。

推荐解决方案：用async/await配合块级作用域 #

现代Node.js最清晰的解决方式是用async/await把异步操作改成“同步”写法，同时用let声明变量保证块级作用域，让循环每次都等待当前数据库操作完成后再执行下一次。

修改后的代码如下：

const mongo = require('mongodb').MongoClient;

// 把整个逻辑包在async函数里
async function processAttendanceRecords() {
  let dbConnection;
  try {
    // 用await等待数据库连接完成
    dbConnection = await mongo.connect(url);
    const dbo = dbConnection.db("mydb");

    // 用let声明循环变量，保证块级作用域
    for (let i = 0; i < totalEmployee; i++) {
      let some = array_data[index].split(":");
      let thing = some[1].split("\"");
      let EID = thing[1];
      let Info = [];
      index++;

      for (let j = 0; j < 2; j++) {
        some = array_data[index].split(":");
        thing = some[1].split("\"");
        let first = thing[1];
        thing = some[2].split("\"");
        let second = thing[0];
        Info[j] = first + ":" + second;
        index++;
      }

      console.log(Info);
      const unique = date + EID;

      // 用await等待查询结果，替代回调
      const existingRecord = await dbo.collection("Attendance").find({ _id: unique }).toArray();

      if (!existingRecord.length) {
        // 等待插入操作完成
        await dbo.collection("Attendance").insertOne({
          _id: unique,
          Date: date,
          EID: EID,
          InTime: Info[0],
          OutTime: Info[1]
        });
        console.log(`Inserted record for EID: ${EID}`);
      } else {
        console.log(`Updating existing record: ${unique}`);
        const updateQuery = { _id: unique };
        const updateValues = {
          $set: {
            Date: date,
            EID: EID,
            InTime: Info[0],
            OutTime: Info[1]
          }
        };
        // 等待更新操作完成
        await dbo.collection("Attendance").updateOne(updateQuery, updateValues);
        console.log(`Updated record for EID: ${EID}`);
      }
    }
  } catch (error) {
    console.error("Processing failed:", error);
    throw error;
  } finally {
    // 确保数据库连接最终关闭
    if (dbConnection) {
      await dbConnection.close();
      console.log("Database connection closed");
    }
  }
}

// 调用处理函数
processAttendanceRecords();

为什么这个方案有效？ #

• async/await强制等待：每次迭代里的数据库操作都会用await等待完成，循环会暂停直到当前操作结束，再进入下一次迭代，彻底解决了“循环跑太快”的问题。
• let避免变量污染：let声明的变量是块级作用域，每次循环迭代都会创建新的变量实例，不会被后续迭代覆盖，确保异步操作能拿到当前迭代的正确值。

兼容旧版本的备选方案：闭包捕获变量 #

如果你的Node.js版本不支持async/await（现在很少见了），可以用立即执行函数表达式（IIFE）来捕获每次循环的变量，避免作用域污染：

mongo.connect(url, function(err, db) {
  if (err) throw err;
  var dbo = db.db("mydb");
  for (var i = 0; i < totalEmployee; i++) {
    // 用IIFE捕获当前迭代的变量
    (function(currentIndex) {
      var some = array_data[currentIndex].split(":");
      var thing = some[1].split("\"");
      var EID = thing[1];
      var Info = [];
      currentIndex++;

      for (var j = 0; j < 2; j++) {
        some = array_data[currentIndex].split(":");
        thing = some[1].split("\"");
        var first = thing[1];
        thing = some[2].split("\"");
        var second = thing[0];
        Info[j] = first + ":" + second;
        currentIndex++;
      }

      console.log(Info);
      var unique = date + EID;

      dbo.collection("Attendance").find({_id: unique}).toArray(function (err, result) {
        if (err) throw err;
        if (!result.length) {
          dbo.collection("Attendance").insertOne({ 
            _id: unique, 
            Date: date, 
            EID: EID, 
            InTime: Info[0], 
            OutTime: Info[1] 
          },function(err, res) {
            if (err) throw err;
            console.log("1 document inserted");
          });
        } else {
          console.log(unique+date+EID+Info[0]);
          var myquery = {_id: unique};
          var newvalues = {$set: {Date: date, EID: EID, InTime: Info[0], OutTime: Info[1]}};
          dbo.collection("Attendance").updateOne(myquery, newvalues, function (err, res) {
            if (err) throw err;
            console.log("1 document updated");
          });
        }
      });
    })(index);
    // 手动更新index，因为IIFE里处理了3条数据
    index += 3;
  }
});

不过这种方式需要手动管理变量和循环进度，代码可读性不如async/await，所以优先推荐第一种方案。

内容的提问来源于stack exchange，提问作者pranta