javascript - 获取ID数组中所有具有匹配ID的元素

Question

我在Express/React Web应用程序中使用Mongoose，并且将数据存储在Mongo数据库中。

我将“歌曲”存储在歌曲集中，例如，用户有一个数组，其中包含他听过的歌曲的ID。

然后，要渲染他一直在听的内容，我必须将具有歌曲ID的数组与来自歌曲集合的歌曲ID链接起来。

我目前正在使用

song.find({_id: {$in: ids}}).exec(callback)

提取与“ids”数组中的id相匹配的所有歌曲。如果用户一次又一次地听这首歌，“ids”数组可能会多次包含相同的id。

事实是， Mongoose 只返回一次对应于id的歌曲，因此不会多次显示该歌曲。有没有一种方法，我不能告诉 Mongoose 将与id重复的对象一样多的对象传递给回调？

总结:

ids: ['a', 'a', 'a', 'b', 'c']
song.find({_id: {$in: ids}}).exec(callback)
dataPassedToCallback: [songA, songB, songC]

期待中

dataPassedToCallback: [songA, songA, songA, songB, songC]

Answer 1

关于您可能要问的问题，这里似乎有几种可能的情况。
从 $in 的 Angular 来看，MongoDB确实将其视为 $or 条件的“简写”，因此实际上这两个语句是相同的:

"field": { "$in": ["a", "a", "a", "b", "c"] }

和

"$or": [
  { "field": "a" },
  { "field": "a" },
  { "field": "a" },
  { "field": "b" },
  { "field": "c" }
]

至少就“他们选择的文档”而言，仅仅是数据库实际包含的“个人”文档。此处的 $in 实际上是最佳的，因为查询引擎可以看到OR在“相同的键”上，这节省了执行查询计划的成本。
另外，仅需注意可以通过 explain() 查看的实际“查询计划执行”实际上将显示“重复”条目已被删除:

        "filter" : {
                "_id" : {
                        "$in" : [
                                "a",
                                "b",
                                "c"
                        ]
                }
        },

值得注意的是，尽管 $or 不会真正删除条件，但这实际上是 $in 作为查询更高效的另一点，即使如此， $or 仍然不会多次获得相同的匹配文档。
但是从“选择”的 Angular 来看，然后要求相同的标准“多次”不会导致检索“多次”。 order of arguments也是如此，因为它们对如何从数据库本身返回订单没有影响。从“数据库”的 Angular 实际检索“多个副本”也没有任何意义，因为这基本上是多余的。
相反，您真正要问的是“我有一个列表，现在我想用数据库中的文档将 替换为这些值”。这实际上是一个合理的要求，而且相对容易实现。您的实际实现实际上仅取决于您从何处获取数据。
映射结果
如果您有一个来自外部来源的“列表”并想要数据库对象，那么逻辑上的事情就是返回匹配的文档，然后用返回的文档替换到您的有序列表中。
在现代的NodeJS环境中，这很简单:

let list = ["a", "a", "a", "b", "c"];
let songs = await Song.find({ "_id": { "$in": list } });

songs = list.map(e => songs.find(s => s._id === e));

现在， songs列表为 list中的每个项目提供了一个条目，其顺序相同，但实际上返回的是真实的数据库文档。
如果要处理 ObjectId中的实际 _id值，则最好“转换”列表中的值，并使用 ObjectId.equals() 函数比较“对象”:

// of course not "valid" ObjectId here; but
let list = ["a", "a", "a", "b", "c"].map(e => ObjectId(e));     // casting
let songs = await Song.find({ "_id": { "$in": list } });

songs = list.map(e => songs.find(s => s._id.equals(e)));        // compare

如果没有从NodeJS 8.x发行版中默认启用 async/await关键字，或者没有在早期版本中显式启用，则标准的Promise解析将执行以下操作:

// of course not "valid" ObjectId here; but
let list = ["a", "a", "a", "b", "c"].map(e => ObjectId(e));     // casting

Song.find({ "_id": { "$in": list } }).then(songs =>
  list.map(e => songs.find(s => s._id.equals(e)))              // compare
).then(songs => {
  // do something
})

或带有回调

let list = ["a", "a", "a", "b", "c"].map(e => ObjectId(e));     // casting
Song.find({ "_id": { "$in": list } },(err,songs) => {
  songs = list.map(e => songs.find(s => s._id.equals(e)));     // compare
})

请注意，这与对问题的评论中提到的“映射功能”显着不同。当您已经从 “一个” 请求中返回了结果时，“多次询问数据库 ”实际上没有任何意义。因此，请执行以下操作:

let songs = await Promise.all(list.map(_id => Song.findById(_id)));

这是非常可怕的冗余，仅为了执行请求就创建了额外的请求和开销。因此，您不会这样做，而是执行“一个”请求并“重新映射”到列表上，因为这样做最有意义。
不过，在实际实现中，更重要的一点是，这种“重新映射”在API的这个级别上仍然没有任何位置。真正应该发生的是“理想地”您的“前端”实际上使用“唯一”的_id列表发出请求。然后，请求通过允许数据库进行响应并简单地返回匹配的文档。作为工作流程:

Front End              Back End                            Front End
---------              ------------                        -------
List -> Unique List -> Endpoint => Database => Endpoint -> Doc List -> Remap List

因此，实际上，从服务器“端点”和“数据库”的 Angular 来看，返回的“文档”应该是它们所处理的全部。通过删除所有重复项，这减少了请求中网络流量的有效负载。仅当在样本中收到“三个”文档的响应时在“前端”进行处理时，您才实际“重新映射”到包含重复副本的最终列表。
填充
另一方面，如果您实际上正在使用文档中已包含的数据，则Mongoose已经支持此功能，其中您的“列表”已经是文档中的数组。例如，作为SongList模型的文档:

{
  "list": ["a", "a", "a", "b", "c"]
}

在该“列表”实际上是对Song模型项目的引用列表的地方调用populate将返回每个“副本”，并按以下顺序存储文档中的列表:

SongList.find().populate('list')

原因是.populate()基本上会使用文档$in字段中找到的参数来发出相同的"list"查询。然后，使用与上面演示的代码完全相同的代码，将这些查询结果实际“映射”到该数组。
因此，如果这是您的实际用例，那么它已经是“内置”的，则无需亲自进行查询:

下面显示了添加“三首”歌曲并使用相同的“映射”技术的示例 list ，并显示了populate()会自动执行的操作

const { Schema, Types: { ObjectId } } = mongoose = require('mongoose');
const { uniq } = require('lodash');

const uri = 'mongodb://localhost/songs';

mongoose.set('debug', true);
mongoose.Promise = global.Promise;

const songSchema = new Schema({
  name: String
});

const songListSchema = new Schema({
  list: [{ type: Schema.Types.ObjectId, ref: 'Song' }]
});

const Song = mongoose.model('Song', songSchema);

const SongList = mongoose.model('SongList', songListSchema);

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

(async function() {

  try {

    const conn = await mongoose.connect(uri);
    const db = conn.connections[0].db;

    let { version } = await db.command({ "buildInfo": 1 });
    version = parseFloat(version.match(new RegExp(/(?:(?!-).)*/))[0]);

    await Promise.all(Object.entries(conn.models).map(([k,m]) => m.remove()));

    let [a,b,c] = await Song.insertMany(['a','b','c'].map(name => ({ name })));

    await SongList.create({ list: [ a, a, b, a, c ] });


    // populate is basically mapping the list
    let popresult = await SongList.find().populate('list');
    log({ popresult });


    // Using an id list
    let list = [a, a, b, a, c].map(e => e._id);

    // Use a unique copy for the $in to save bandwidth
    let unique = uniq(list);


    // Map the result
    let songs = await Song.find({ _id: { $in: unique } });
    songs = list.map(e => songs.find(s => s._id.equals(e)));
    log({ songs })


    if ( version >= 3.4 ) {
    // Force the server to return copies
      let stupid = await Song.aggregate([
        { "$match": { "_id": { "$in": unique } } },
        { "$addFields": {
          "copies": {
            "$filter": {
              "input": {
                "$map": {
                  "input": {
                    "$zip":  {
                      "inputs": [
                        { "$literal": list },
                        { "$range": [0, { "$size": { "$literal": list } } ] }
                      ]
                    }
                  },
                  "in": {
                    "_id": { "$arrayElemAt": [ "$$this", 0 ] },
                    "idx": { "$arrayElemAt": [ "$$this", 1 ] }
                  }
                }
              },
              "cond": { "$eq": ["$$this._id", "$_id"] }
            }
          }
        }},
        { "$unwind": "$copies" },
        { "$sort": { "copies.idx": 1 } },
        { "$project": { "copies": 0 } }
      ]);
      log({ stupid })

    }

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


})()

这将为您提供如下输出:

Mongoose: songs.remove({}, {})
Mongoose: songlists.remove({}, {})
Mongoose: songs.insertMany([ { _id: 5b06c2ff373eb00d9610aa6e, name: 'a', __v: 0 }, { _id: 5b06c2ff373eb00d9610aa6f, name: 'b', __v: 0 }, { _id: 5b06c2ff373eb00d9610aa70, name: 'c', __v: 0 } ], {})
Mongoose: songlists.insertOne({ list: [ ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6f"), ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa70") ], _id: ObjectId("5b06c2ff373eb00d9610aa71"), __v: 0 })
Mongoose: songlists.find({}, { fields: {} })
Mongoose: songs.find({ _id: { '$in': [ ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6f"), ObjectId("5b06c2ff373eb00d9610aa70") ] } }, { fields: {} })
{
  "popresult": [
    {
      "list": [
        {
          "_id": "5b06c2ff373eb00d9610aa6e",
          "name": "a",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa6e",
          "name": "a",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa6f",
          "name": "b",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa6e",
          "name": "a",
          "__v": 0
        },
        {
          "_id": "5b06c2ff373eb00d9610aa70",
          "name": "c",
          "__v": 0
        }
      ],
      "_id": "5b06c2ff373eb00d9610aa71",
      "__v": 0
    }
  ]
}
Mongoose: songs.find({ _id: { '$in': [ ObjectId("5b06c2ff373eb00d9610aa6e"), ObjectId("5b06c2ff373eb00d9610aa6f"), ObjectId("5b06c2ff373eb00d9610aa70") ] } }, { fields: {} })
{
  "songs": [
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6f",
      "name": "b",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa70",
      "name": "c",
      "__v": 0
    }
  ]
}
Mongoose: songs.aggregate([ { '$match': { _id: { '$in': [ 5b06c2ff373eb00d9610aa6e, 5b06c2ff373eb00d9610aa6f, 5b06c2ff373eb00d9610aa70 ] } } }, { '$addFields': { copies: { '$filter': { input: { '$map': { input: { '$zip': { inputs: [ { '$literal': [Array] }, { '$range': [Array] } ] } }, in: { _id: { '$arrayElemAt': [ '$$this', 0 ] }, idx: { '$arrayElemAt': [ '$$this', 1 ] } } } }, cond: { '$eq': [ '$$this._id', '$_id' ] } } } } }, { '$unwind': '$copies' }, { '$sort': { 'copies.idx': 1 } }, { '$project': { copies: 0 } } ], {})
{
  "stupid": [
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6f",
      "name": "b",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa6e",
      "name": "a",
      "__v": 0
    },
    {
      "_id": "5b06c2ff373eb00d9610aa70",
      "name": "c",
      "__v": 0
    }
  ]
}

“愚蠢的”聚合技巧
这确实不是解决方案，但实际上更多的是在其他人提及它或类似内容之前，发表了有关该主题的文章。
实际上，更多地属于“愚蠢的把戏”类别的服务器实际上迫使服务器返回文档的“副本”。

let stupid = await Song.aggregate([
  { "$match": { "_id": { "$in": list } } },
  { "$addFields": {
    "copies": {
      "$filter": {
        "input": {
          "$map": {
            "input": {
              "$zip":  {
                "inputs": [
                  list,
                  { "$range": [0, { "$size": { "$literal": list } } ] }
                ]
              }
            },
            "in": {
              "_id": { "$arrayElemAt": [ "$$this", 0 ] },
              "idx": { "$arrayElemAt": [ "$$this", 1 ] }
            }
          }
        },
        "cond": { "$eq": ["$$this._id", "$_id"] }
      }
    }
  }},
  { "$unwind": "$copies" },
  { "$sort": { "copies.idx": 1 } },
  { "$project": { "copies": 0 } }
]);

实际上，这将从服务器返回所有文档“副本”。它通过对 $unwind 处理的列表输出上的 $filter 进行操作，以仅保留那些与当前文档_id匹配的值。倍数将保留在该数组中，当使用 $unwind 处理该数组时，将为每个数组条目有效地生成文档的“副本”。
另外，我们通过 "idx" 和 $zip 将“索引”位置映射到数组中，从而将列表中项目的$range保留在列表中。然后，下面的 $sort 将按照它们在输入列表中的显示顺序放置文档，以模仿Array.map()，该操作已在您应使用的代码中完成。
然后，我们可以简单地 $project 来“排除”该字段，该字段仅作为临时措施。
综上所述，做这样的事情并不是一个好主意。如前所述，您这样做实际上是在增加有效负载，而在客户端中构造“映射”实际上要合乎逻辑得多。理想情况下，正如已经提到的，“最终”客户端。