我在Express / React Web应用程序中使用Mongoose，并且我将数据存储在Mongo数据库中。
我存储歌曲＆＃39;在歌曲集合中，用户有一个数组，其中包含他收听的歌曲的ids。
然后为了呈现他正在听的内容，我必须将数组与歌曲ID与歌曲集合中的歌曲ID相关联。
我目前正在使用
song.find({_id: {$in: ids}}).exec(callback)
获取与“ids”中的ID相匹配的所有歌曲。阵列。 ＆＃39; ids＆＃39;如果用户一次又一次地听过这首歌，那么array可能会多次包含相同的id。
事情是，猫鼬只返回一次与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]
答案 0 :(得分：2)
这里似乎有一些关于你可能会问的问题。
从$in的角度来看，MongoDB真的把它当作＆＃34;简写＆＃34;对于$or条件如此有效，这两个语句是相同的：
"field": { "$in": ["a", "a", "a", "b", "c"] }
和
"$or": [
{ "field": "a" },
{ "field": "a" },
{ "field": "a" },
{ "field": "b" },
{ "field": "c" }
]
至少就他们选择的＆＃34;文件而言，＆＃34;这只是＆＃34;个人＆＃34;数据库实际包含的文档。 $in实际上在这里更优化，因为查询引擎可以看到OR位于＆＃34;相同的键＆＃34;上，这样可以节省查询计划执行中的一些成本。
另外，只需要注意实际的＆＃34;查询计划执行＆＃34;可以用explain()查看的内容实际上会显示＆＃34;重复＆＃34;无论如何都会删除条目：
"filter" : {
"_id" : {
"$in" : [
"a",
"b",
"c"
]
}
},
值得注意的是，虽然$or实际上并不会删除这些条件，但这实际上只是$in作为查询更有效的另一个原因，即便如此$or仍然是不会多次获得相同的匹配文档。
但是从＆＃34;选择＆＃34;的角度来看，然后要求相同的标准＆＃34;多次＆＃34;不会导致检索＆＃34;多次＆＃34;。 order of arguments的情况也是如此，因为它们对数据库本身的顺序返回方式没有影响。实际检索＆＃34;多份副本＆＃34;真的没有任何意义。来自＆＃34;数据库＆＃34;因为这基本上是多余的。
相反，你真正要求的是＆＃34;我有一个列表，现在我想用数据库中的文件替换这些值＆＃34; 。这实际上是一个合理的问题，而且相对容易实现。您的实际实施实际上取决于您从何处获取数据。
如果你有一个＆＃34;列表＆＃34;从外部源和想要数据库对象，然后逻辑事情是返回匹配的文档，然后用返回的文档替换到您的有序列表。
在现代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值，那么最好是＆＃34;施放＆＃34;列表中的值并使用ObjectId.equals()函数来比较＆＃34;对象＆＃34;：
// 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
})
请注意，这与＆＃34;映射功能＆＃34;显着不同。正如在评论中提到的那样。当你已经从＆＃34;一个＆＃返回结果时，＆＃34;多次询问数据库 ＆＃34; 毫无意义34; 请求。因此做一些事情：
let songs = await Promise.all(list.map(_id => Song.findById(_id)));
这是非常可怕的冗余，只是为了做请求而创建额外的请求和开销。所以你不会这样做，而是做一个＆＃34;一个＆＃34;请求和＆＃34;重新映射＆＃34;因为它只是最有意义，所以列在清单上。
更重要的是，实际的实现方式是这个＆＃34;重新映射＆＃34;仍然没有在这个级别的API。真正应该发生的事情是＃34;理想情况下＆＃34;你的前端＆＃34;实际上使用＆＃34; unique＆＃34; _id仅列出＆＃34;＆＃34; 。然后通过允许数据库响应并简单地返回匹配的文档来传递请求。作为工作流程：
Front End Back End Front End
--------- ------------ -------
List -> Unique List -> Endpoint => Database => Endpoint -> Doc List -> Remap List
所以真的来自服务器＆＃34; Endpoint＆＃34;和＆＃34;数据库＆＃34;分析＆＃34;文件＆＃34;返回应该是他们处理的全部。这通过删除所有重复项来减少请求中的网络流量的有效负载。只有在＆＃34;前端处理时才会进行处理。当收到那些＆＃34;三个＆＃34;样本中的文件实际上是否会重新映射＆＃34;到包含重复副本的最终列表。
另一方面，如果您实际上正在使用文档中已包含的数据，那么Mongoose已经支持您的＆＃34; list＆＃34;已经是文档中的数组。例如，作为SongList模型的文档：
{
"list": ["a", "a", "a", "b", "c"]
}
调用填充“＆＃34; list＆＃34;实际上是Song模型项的引用列表将返回每个＆＃34; copy＆＃34;并且为了使文档中的列表存储为：
SongList.find().populate('list')
原因是.populate()基本上发出相同的$in查询，使用文档"list"字段中的参数。那些查询结果实际上是＆＃34;映射＆＃34;使用上面演示的完全相同的代码到该数组上。
因此，如果这是您的实际用例，那么这已经是＆＃34;内置＆＃34;而且没有必要自己去查询：
以下是添加＆＃34;三＆＃34;的示例列表。歌曲并使用相同的＆＃34;映射＆＃34;技巧以及显示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
}
]
}
这真的不是一个解决方案，但在其他人提到它或类似的事情之前，它确实更像是一个关于这个主题的帖子。
更多属于＆＃34;愚蠢的技巧＆＃34;实际上是强迫服务器返回＆＃34;副本＆＃34;文件。
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 } }
]);
这实际上将返回所有文件＆＃34;副本＆＃34;从服务器。它通过使用$unwind处理的列表输出上的$filter执行此操作，以仅保留与当前文档_id匹配的值。倍数将保留在该数组中，当使用$unwind处理时，有效地产生了一个＆＃34;副本＆＃34;每个数组条目的文档。
作为奖励，我们通过映射＆＃34;索引＆＃34;来保留列表中项目的"idx"。通过$zip和$range定位到数组中以下$sort将按照文档在输入列表中的显示顺序放置文档，只是为了模仿Array.map()在你应该使用的代码中完成。
我们可以简单$project来＆＃34;排除＆＃34;那个领域只是作为一种临时措施。
所有这些都说，做这样的事情并不是一个好主意。正如已经提到的那样，你实际上是通过这样做来增加有效载荷，当它构建＆＃34;映射＆＃34;时更合乎逻辑。在客户端。理想情况下，＆＃34;结束＆＃34;客户已如上所述。