Javascript 如何在异步等待的严格模式下正确使用集合

因此，我试图找出如何将集合

strict

模式与async/await结合使用。它需要回调，但我不知道如何正确使用它，因为它似乎没有运行任何命令

它给出了错误：

UnhandledPromiseRejectionWarning: MongoError: server instance pool was destroyed

这是我到目前为止所拥有的

    const cursor = 
        await
        db
            .collection(
                "invalidator",
                {
                    strict: true
                },
                async function (error, cursor) 
                {
                    console.log(chalk.yellow("running callback"))
                    const result = await
                    cursor
                        .insertOne({
                            // created: new Date(),
                            test: "test"
                        })

                    console.log(result)
                }
            )

db

只是MongoClient

    const db = await MongoClient.connect(
        url,
        {
            useNewUrlParser: true,
        },
    )

只是想澄清一下，该方法不会返回

承诺

。实际上，它并不打算返回任何内容，而

回调

接口仅用于“严格模式”，这意味着当您随后尝试执行任何操作时，MongoDB无法“创建一个不存在于给定名称下的集合”

在最短的演示程序中，如果您打算

等待
回调中的操作，则基本上需要手动将“整个事情”包装在
承诺中
：

const { MongoClient } = require('mongodb');

const uri = 'mongodb://localhost:27017';
const opts = { useNewUrlParser: true };

const log = data => console.log(JSON.stringify(data, undefined, 2));

(async function() {

  try {
    const client = await MongoClient.connect(uri, opts);

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

    // Expect to wait or fail if the collection named does not already exist
    await new Promise((resolve, reject) => {
      db.collection('test', { strict: true }, async (err, collection) => {
        if (err) reject(err);

        // really should have an "inner" try..catch to "bubble" any errors.
        try {
          // insert something
          let result = await collection.insertOne({ a: 1 });
          log(result);
          resolve();               // resolve the Promise
        } catch(e) {
          reject(e);
        }
      });
    })
    log("I waited");

    client.close();

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

为了完整性起见，您确实应该在回调的任何“内部”操作周围使用
try..catch
，例如在
catch
块中的任何错误上使用here和successly
reject（）
。
async使函数返回承诺。我想你只需要回电话。为什么您认为这里需要异步
.collection（）
不返回承诺。如果您希望“等待”内部
回调的完成
，那么您需要“手动”将整个过程包装在
承诺中。i、 e
wait new Promise（（resolve，reject）=>db.collection（'name'，（err，collection）=>/*do stuff*/resolve（））
@NeilLunn我在没有异步的情况下尝试了它，但我不确定如何取回集合实例。我在回调中尝试了一个
返回集合
，但它给了我一个
类型错误：无法读取未定义的@JimB的属性'insertOne'。为了继续查询，我只是尝试获取实例，因为它给了我
TypeError:cannotread属性'insertOne'的undefined
您没有检查错误。有错误吗？所以我使用
{strict:true}
的主要原因是为了确保我没有插入到不存在的集合中（以防拼写错误）。当我没有包含
{strict:true}
@A.Lau时，我可以使用async/wait fine。我“假定”这个
严格的
是由
回调所暗示的，但实际上并非如此。清单已更正/测试并按预期工作。要获得原始效果，似乎是一种相当笨拙的方法，但包含了
{strict:true}
。但我想至少是这样works@A.Lau您可以简单地将获取集合引用封装在一个承诺中，即
let collection=wait new promission（（resolve，reject）=>db.collection（'test'，{strict:true}，（err，collection）=>{if（err）reject（err）；resolve（collection）}）
如果这更符合您的感受，但基本点是驱动程序方法不会以本机方式返回一个
承诺
，就像其他任何类似的情况一样，您可以自己手动进行包装。或者，如果您已经将此类内容作为依赖项加载，则由其他外部库“promisify”。