Javascript 如何并行执行更新

我注意到，当我使用

newpromise（async（resolve，reject）

与

newpromise（（resolve，reject））

相比时，它正在执行查询，我在我的

Promise.all（[]）上得到了我想要的结果。然后

块像：

      const borrowersFeePromise = new Promise(async (resolve, reject) => {
        if (borrowersFee !== undefined && borrowersFee !== '') {
          const borrowersFeeUpserted = await Fees.update(
            {
              personId: mongoose.Types.ObjectId(personId),
              category: 'borrowersFee',
            },
            {
              $set: {
                amount: borrowersFee,
              },
            },
            { upsert: true },
          );
          resolve({
            upsert: borrowersFeeUpserted,
            hasPassed: true,
          });
        } else {
          resolve({
            upsert: null,
            hasPassed: true,
          });
        }
      });

      const extendedFeePromise = new Promise(async (resolve, reject) => {
        if (extendedFee !== undefined && extendedFee !== '') {
          const extendedFeeUpserted = await Fees.update(
            {
              personId: mongoose.Types.ObjectId(personId),
              category: 'extendedFee',
            },
            {
              $set: {
                amount: extendedFee,
              },
            },
            { upsert: true },
          );
          resolve({
            upsert: extendedFeeUpserted,
            hasPassed: true,
          });
        } else {
          resolve({
            upsert: null,
            hasPassed: true,
          });
        }
      });

      await Promise.all([
        borrowersFeePromise,
        extendedFeePromise,
      ]).then((feesResult) => {
        console.log(feesResult);

        /*
          outputs something like:
          [ { upsert: { n: 1, nModified: 1, ok: 1 }, hasPassed: true },
            { upsert: { n: 1, nModified: 1, ok: 1 }, hasPassed: true } ]
        */
      });   

但是，当我只使用

newpromise（（resolve，reject）

时，它不会执行查询，并输出如下内容：

 [   { upsert:
    Query {
      _mongooseOptions: {},
      mongooseCollection: [Object],
      model: [Object],
      schema: [Object],
      op: 'update',
      options: [Object],
      _conditions: [Object],
      _fields: undefined,
      _update: [Object],
      _path: undefined,
      _distinct: undefined,
      _collection: [Object],
      _traceFunction: undefined,
      _count: [Function],
      _execUpdate: [Function],
      _find: [Function],
      _findOne: [Function],
      _findOneAndRemove: [Function],
      _findOneAndUpdate: [Function],
      _replaceOne: [Function],
      _updateMany: [Function],
      _updateOne: [Function] },
   hasPassed: true },
 ....]    

我认为承诺应该等待执行，但为什么它只在我放入

async（解析，拒绝）时执行

？我的目的是在运行

Promise时同时执行这两项费用。所有的
，就像非阻塞命令一样。这是我在观看和重新观看有关它的教程后理解承诺的方式。我做错了吗

非常感谢。
据我所知，这正是您真正想要的：

await Promise.all([
  Fees.update(
        {
          personId: mongoose.Types.ObjectId(personId),
          category: 'borrowersFee',
        },
        {
          $set: {
            amount: borrowersFee,
          },
        },
        { upsert: true },
  ),
  Fees.update(
        {
          personId: mongoose.Types.ObjectId(personId),
          category: 'extendedFee',
        },
        {
          $set: {
            amount: extendedFee,
          },
        },
        { upsert: true },
  )
])

但实际上，你应该这样做：

let results = await Fees.bulkWrite([
  { "updateOne": { 
    "filter": {
      personId: mongoose.Types.ObjectId(personId),
      category: 'borrowersFee',
    },
    "update": { $set: { amount: borrowersFee } },
    "options": { upsert: true },
 }},
 { "updateOne": { 
    "filter": {
      personId: mongoose.Types.ObjectId(personId),
      category: 'extendedFee',
    },
    "update": { $set: { amount: extendedFee } },
    "options": { upsert: true },
 }}
],{ "ordered": false })

使用该方法意味着“一个”请求通过线路发送到服务器，而不是执行单独的语句来并行解析所需的“两个”。因此，不仅它们减少的开销使其更快，而且
{“ordered”：false}
确保它们实际并行运行“在服务器上”。
据我所知，这是您真正想要的：

await Promise.all([
  Fees.update(
        {
          personId: mongoose.Types.ObjectId(personId),
          category: 'borrowersFee',
        },
        {
          $set: {
            amount: borrowersFee,
          },
        },
        { upsert: true },
  ),
  Fees.update(
        {
          personId: mongoose.Types.ObjectId(personId),
          category: 'extendedFee',
        },
        {
          $set: {
            amount: extendedFee,
          },
        },
        { upsert: true },
  )
])

但实际上，你应该这样做：

let results = await Fees.bulkWrite([
  { "updateOne": { 
    "filter": {
      personId: mongoose.Types.ObjectId(personId),
      category: 'borrowersFee',
    },
    "update": { $set: { amount: borrowersFee } },
    "options": { upsert: true },
 }},
 { "updateOne": { 
    "filter": {
      personId: mongoose.Types.ObjectId(personId),
      category: 'extendedFee',
    },
    "update": { $set: { amount: extendedFee } },
    "options": { upsert: true },
 }}
],{ "ordered": false })

使用该方法意味着“一个”请求通过线路发送到服务器，而不是执行单独的语句以并行方式解析所需的“两个”。因此，不仅是它们减少的开销使其更快，而且
{“ordered”：false}
确保它们实际并行运行在服务器上".
你为什么要写一个承诺？mongoose API上的所有方法都已经返回了一个承诺。事实上，你已经在等待它们了。你为什么认为你需要做你正在做的事情，这确实令人困惑。@Neil Lunn，这就是我为什么要问的原因，因为我看到了一个关于承诺的教程。所有这些方法都同时执行命令，而我希望同时执行我的mongoose update命令…所以我使用Promise.all。有一个更好的方法来实现你的目标。看看答案。你为什么要写一个Promise？mongoose API上的所有方法都已经返回了一个Promise。事实上，你已经在等待它们了。为什么你认为你需要这么做你正在做的事情确实令人困惑。@尼尔·伦恩，这就是我为什么要问的原因，因为我看到了一个关于Promise.all的教程，它同时执行命令，我希望同时执行我的mongoose update命令……所以我使用Promise.all。有一个更好的方法来完成你正在尝试的事情。请看答案。仅供参考跳过所有中间件。验证也是一个中间件。我相信这也会被跳过。可能应该只对种子数据执行此操作，但也可能不会真正执行此操作，因为您希望确保插入的是有效的种子数据。@GovindRai我可能应该包含免责声明。我认为好处远远大于缺点在性能应用程序中，你实际上并不是“每个对象”进行验证，而是首先检查要提交的“批”数据。仅仅因为你想在你的模式中启动一个“验证器”，就提出1000个请求实际上是一个可笑的建议。所以“预验证”就是按照我在这里说的去做。我可能对它也有一些深入的经验。仅供参考，bulkWrite跳过了所有中间件。验证也是一个中间件。我相信这也会被跳过。可能应该只对种子数据这样做，但也可能不是真的那样，因为您希望确保插入有效的种子数据ata.@GovindRai我可能应该包括免责声明。在高性能应用程序中，好处远远大于“验证”等的损失。实际上，您并不是“每个对象”都这样做，而是先检查要提交的“一批”数据。仅因为您需要“验证程序”，就提出1000个请求在你的模式中，fire实际上是一个可笑的建议。所以“preferred”就是按照我在这里说的去做。我可能也对它有一些深入的经验。