我想对不带数字键 (_id) 的 mongoDB 集合执行迭代。该集合只有随机字符串作为 _id，并且集合的大小很大，因此使用 .toArray() 将整个文档加载到 RAM 上不是一个可行的选择。另外我想对每个元素执行异步任务。 .map() 或 .each(), .forEach() 的使用受到限制，因为任务的异步性质。我尝试使用那些提到的方法运行任务，但它当然与异步任务冲突，返回未决的 promise 而不是正确的结果。

示例

async function dbanalyze(){

  let cursor = db.collection('randomcollection').find()
  for(;;){
    const el = cursor.hasNext() ? loaded.next() : null;
    if(!cursor) break
    await performAnalyze(cursor) // <---- this doesn't return a document but just a cursor object
  }

}

如何仅使用 for() 遍历 mongoDB 集合？

最佳答案

Cursor.hasNext()方法也是“异步的”，因此您也需要 await。同样适用于 Cursor.next() .因此，实际的“循环”用法确实应该是 while:

async function dbanalyze(){

  let cursor = db.collection('randomcollection').find()
  while ( await cursor.hasNext() ) {  // will return false when there are no more results
    let doc = await cursor.next();    // actually gets the document
    // do something, possibly async with the current document
  }

}

如评论中所述，最终 Cursor.hasNext()当光标实际耗尽时将返回 false，并且 Cursor.next()是实际从游标中检索每个值的东西。当 hasNext() 为 false 时，您可以执行其他结构并中断 循环，但它更自然地适用于 while.

这些仍然是“异步的”，因此您需要等待每个 promise 的解决方案，这是您缺少的主要事实。

至于Cursor.map() ，那么你可能错过了它也可以在提供的函数上用 async 标志标记的观点:

 cursor.map( async doc => {                   // We can mark as async
    let newDoc = await someAsyncMethod(doc);  // so you can then await inside
    return newDoc;
 })

但您实际上仍然想在某个地方“迭代”它，除非您可以使用 .pipe() 到其他输出目的地。

async/await 标志也使 Cursor.forEach() “再次变得更实用”，因为它的一个常见缺陷是无法简单地处理“内部”异步调用，但是有了这些标志，您现在可以轻松地做到这一点，尽管不可否认，因为您 必须使用回调，您可能希望将其包装在 Promise 中:

await new Promise((resolve, reject) => 
  cursor.forEach(
    async doc => {                              // marked as async
      let newDoc = await someAsyncMethod(doc);  // so you can then await inside
      // do other things
    },
    err => {
      // await was respected, so we get here when done.
      if (err) reject(err);
      resolve();
    }
  )
);

当然，总有一些方法可以通过回调或普通的 Promise 实现来应用它，但它是 async/await 的“糖分”，实际上使它看起来更清晰。

NodeJS v10.x 和 MongoDB Node 驱动程序 3.1.x 及更高版本

最喜欢的版本使用 AsyncIterator，它现在在 NodeJS v10 及更高版本中启用。这是一种更简洁的迭代方式

async function dbanalyze(){

  let cursor = db.collection('randomcollection').find()
  for await ( let doc of cursor ) {
    // do something with the current document
  }    
}

“在某种程度上” 回到了最初提出的关于使用 for 循环的问题，因为我们可以执行 for-await-of 这里的语法支持支持正确接口(interface)的可迭代。 Cursor 确实支持此接口(interface)。

如果您很好奇，下面是我前段时间编写的 list ，用于演示各种游标迭代技术。它甚至包括 Async Iterators from a generator function 的案例:

const Async = require('async'),
      { MongoClient, Cursor } = require('mongodb');

const testLen = 3;
(async function() {

  let db;

  try {
    let client = await MongoClient.connect('mongodb://localhost/');

    let db = client.db('test');
    let collection = db.collection('cursortest');

    await collection.remove();

    await collection.insertMany(
      Array(testLen).fill(1).map((e,i) => ({ i }))
    );

    // Cursor.forEach
    console.log('Cursor.forEach');
    await new Promise((resolve,reject) => {
      collection.find().forEach(
        console.log,
        err => {
          if (err) reject(err);
          resolve();
        }
      );
    });

    // Async.during awaits cursor.hasNext()
    console.log('Async.during');
    await new Promise((resolve,reject) => {

      let cursor = collection.find();

      Async.during(
        (callback) => Async.nextTick(() => cursor.hasNext(callback)),
        (callback) => {
          cursor.next((err,doc) => {
            if (err) callback(err);
            console.log(doc);
            callback();
          })
        },
        (err) => {
          if (err) reject(err);
          resolve();
        }
      );

    });

    // async/await allows while loop
    console.log('async/await while');
    await (async function() {

      let cursor = collection.find();

      while( await cursor.hasNext() ) {
        let doc = await cursor.next();
        console.log(doc);
      }

    })();

    // await event stream
    console.log('Event Stream');
    await new Promise((end,error) => {
      let cursor = collection.find();

      for ( let [k,v] of Object.entries({ end, error, data: console.log }) )
        cursor.on(k,v);
    });

    // Promise recursion
    console.log('Promise recursion');
    await (async function() {

      let cursor = collection.find();

      function iterate(cursor) {
        return cursor.hasNext().then( bool =>
          (bool) ? cursor.next().then( doc => {
            console.log(doc);
            return iterate(cursor);
          }) : Promise.resolve()
        )
      }

      await iterate(cursor);

    })();

    // Uncomment if node is run with async iteration enabled
    // --harmony_async_iteration


    console.log('Generator Async Iterator');
    await (async function() {

      async function* cursorAsyncIterator() {
        let cursor = collection.find();

        while (await cursor.hasNext() ) {
          yield cursor.next();
        }

      }

      for await (let doc of cursorAsyncIterator()) {
        console.log(doc);
      }

    })();


    // This is supported with Node v10.x and the 3.1 Series Driver
    await (async function() {

      for await (let doc of collection.find()) {
        console.log(doc);
      }

    })();

    client.close();

  } catch(e) {
    console.error(e);
  } finally {
    process.exit();
  }

})();

关于javascript - 带有异步子任务的异步游标迭代，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49848883/