Mongoose填充多个数组中的嵌套元素
Mongoose是一个针对Node.js和MongoDB的对象模型工具库，用于在应用程序中进行MongoDB数据库的建模和操作。Mongoose填充多个数组中的嵌套元素是指在Mongoose中如何处理包含多个数组并且数组中元素也是数组的情况。
在Mongoose中，可以使用populate方法来填充多个数组中的嵌套元素。populate方法可以将对应文档的引用字段填充为实际的文档对象，从而实现嵌套元素的填充。
下面是一个示例：
const mongoose = require('mongoose');
// 定义模式
const userSchema = new mongoose.Schema({
name: String,
posts: [{
type: mongoose.Schema.Types.ObjectId,
ref: 'Post'
}]
});
const postSchema = new mongoose.Schema({
title: String,
comments: [{
type: mongoose.Schema.Types.ObjectId,
ref: 'Comment'
}]
});
const commentSchema = new mongoose.Schema({
content: String
});
// 定义模型
const User = mongoose.model('User', userSchema);
const Post = mongoose.model('Post', postSchema);
const Comment = mongoose.model('Comment', commentSchema);
// 填充嵌套元素
User.findOne({ name: 'John' })
.populate({
path: 'posts',
populate: {
path: 'comments'
}
})
.exec((err, user) => {
if (err) {
console.error(err);
} else {
console.log(user);
}
});在上面的示例中，我们定义了三个模型：User、Post和Comment，User模型包含一个posts字段，Post模型包含一个comments字段，而Comment模型只有一个content字段。通过调用populate方法并传入一个对象参数，我们可以指定要填充的字段和填充的规则。在这个例子中，我们使用populate方法填充了User模型中的posts字段，然后再填充posts中的comments字段。最后，通过调用exec方法执行查询，并将填充后的结果打印到控制台。
这是Mongoose中填充多个数组中的嵌套元素的方法。需要注意的是，具体的填充规则会根据实际的数据模型和需求而有所差异，上述示例只是一个简单的演示。在实际的开发中，可以根据具体的情况进行相应的调整和扩展。
推荐的腾讯云相关产品：无
参考链接：
- Mongoose官方文档：https://mongoosejs.com/
- Mongoose populate方法文档：https://mongoosejs.com/docs/populate.html
相关·内容
2回答
这是我的方案：
var userSchema = {
folders : [ folderSchema ],
...
}
var folderSchema = new mongoose.Schema({
itemlist : [{ type: String, ref: 'Item', required: true }],
foldername : { type: String},
...
});
// Item model
var itemSchema = {
name: { type: String },
.
浏览 0提问于2016-10-20得票数 0
1回答
猫鼬.populate()不填充
、、、、
我尝试了几种不同的方法，但无法让Mongoose将Users信息填充到Items集合中。
文件： users.js
var mongoose = require( 'mongoose' )
Schema = mongoose.Schema,
ObjectId = Schema.Types.ObjectId;
var userSchema = Schema( {
_id: ObjectId,
barcode: String,
name: String,
email: String,
type: String
} );
v
浏览 0提问于2015-11-13得票数 2
回答已采纳
1回答
猫鼬巢/深种群
、、、、
我知道这个问题已经被问了很多次了，但是我对mongodb/猫鼬有点陌生！目前，我正在为一个医学软件做一个平均堆栈。以下是我的模式：
var usersSchema = new Schema({
_id : {type : mongoose.Schema.ObjectId}
//...
});
mongoose.model('Users', usersSchema);
var doctorsSchema = new Schema({
_id : {type : mongoose.Schema.ObjectId},
userid
浏览 3提问于2014-12-10得票数 2
我有两个模式： const mongoose = require('mongoose');
const PinSchema = new mongoose.Schema({
title: String,
content: String,
image: String,
latitude: Number,
longitude: Number,
author: {
type: mongoose.Schema.ObjectId,
ref: "User"
},
comments: [
{
text: S
浏览 15提问于2019-09-20得票数 0
回答已采纳
1回答
我有两个猫鼬模式/模型。一个用于球员的Team，另一个用于Players本身。
Team
// Other less relevant stuff
goalkeepers: [{
type: mongoose.Schema.Types.ObjectId,
ref: 'Player'
}],
defenders: [{
type: mongoose.Schema.Types.ObjectId,
ref: 'Player'
}],
midfielders: [{
type: mongoose.Schema.Types.ObjectId,
re
浏览 4提问于2016-10-04得票数 1
回答已采纳
1回答
我正在尝试模拟一个填充调用，并且我希望模拟返回mongoose对象，而不是普通的JS对象。
sandbox.mock(BookModel)
.expects('populate')
.yields(null, [
new BookModel({
_id: mongoose.Types.ObjectId(),
name: 'Mock Book',
authorIds: [{
name: 'Foo',
}]
})
]);
使用模式：
var BookSchem
浏览 15提问于2017-08-08得票数 1
回答已采纳
2回答
用引用数组填充和搜索猫鼬
、、、、
我正试图把我的头脑集中在猫鼬填充的语法和结构上。我有两个模式。父有一个子引用数组。
const Parent = new Schema({
name: String,
children: [{type: Schema.ObjectId, ref: 'Child'}]
});
const Child = new Schema({
name: String
});
为了填充父，我一直在这样做：
Parent
.findById(parent.id)
.populate('children')
.exec( (err, parent) =
浏览 4提问于2016-02-18得票数 1
回答已采纳
我刚刚开始使用Mongoose，并且正在尝试使用一个非常基本的示例来使populate()工作。目前我有两个模型，一个是汽车模型，一个是车主模型。 所有者 const mongoose = require('mongoose')
module.exports = mongoose.model('Owner', mongoose.Schema({
name: String,
cars: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Car' }]
})) 小汽车 const mongoos
浏览 12提问于2020-02-03得票数 0
回答已采纳
1回答
我正在尝试使用mongoose js，特别是相同的模式来嵌套模式，以创建一个类似树的结构。在此配置中，文档只能有一个父文档，但同一文档可以是多个子文档的父文档。下面是我最初是如何处理它的：
var mongoose = require('mongoose'),
Schema = mongoose.Schema,
ObjectId = Schema.ObjectId;
var mySchema = new Schema({
_id: {
type: ObjectId,
required: true
},
parent: {
浏览 1提问于2015-09-21得票数 3
回答已采纳
我有两个模式--匹配模式和成员模式。Match包含一个成员数组。
var MatchSchema = new Schema({name: String, players: [{
player: {
type: Schema.ObjectId,
ref: 'Member'},
play: Boolean}]});
var MemberSchema = new Schema({
firstName: String,
lastName: String});
我正在尝试使用per 填充ObjectIds
.populat
浏览 3提问于2017-01-22得票数 1
我正在查询一个mongo文档来检索数组信息。问题是我的数组在另一个数组中。我不知道这是怎么回事。我每次都得映射两次才能进去。有人知道为什么吗？ 下面是mongoose模式： const mongoose = require("mongoose");
const mongo = require("mongodb");
const insertedLaw = require("./civilcode_section2_21.json");
const Law = mongoose.model(
"Laws",
浏览 16提问于2020-06-27得票数 0
回答已采纳
1回答
抱歉如果标题看起来很复杂..。我想不出更好的方法来描述它了。
我的实际情况符合以下方案：
Collection1
const mongoose = require('mongoose');
const itemSchema = mongoose.Schema({
_id: mongoose.Schema.Types.ObjectId,
name: { type: String, required: [true, 'Name is required.'] },
quantity: { type: Number, r
浏览 0提问于2018-08-20得票数 0
回答已采纳
4回答
我有以下mongoose模式结构
userSchema = new Schema({
roles: [
role: {type: Schema.Types.ObjectId, ref: 'Role' }
]
})
rolesSchema = new Schema({
name: String,
roleEntities: [
{
entity : {type: Schema.Types.ObjectId, ref: 'RoleEntity' },
abilities : [{type: S
浏览 3提问于2016-05-03得票数 14
我在猫鼬中有以下模式。
var AttendanceSchema = new mongoose.Schema({
ownerId: mongoose.Schema.Types.ObjectId,
companyId: mongoose.Schema.Types.ObjectId,
months: [
{
currentSalary: {
type: Number,
default: 0
},
month: {
type: Date,
},
salary: {
浏览 0提问于2018-10-18得票数 0
1回答
我正在尝试对子数组数据进行排序。以下是涉及到的模型：
操作员模型：
const mongoose = require('mongoose');
var deepPopulate = require('mongoose-deep-populate')(mongoose);
const Schema = mongoose.Schema;
const OperatorSchema = new Schema({
value: {type: String, required: true},
displaySort: {type: Number, requi
浏览 10提问于2019-08-16得票数 0
3回答
我到处寻找，但不知道如何形成下面的填充查询，首先是我的模型：
const CourseSchema = new Schema({
classes: [{ type: Schema.Types.ObjectId, ref: 'Classroom' }]
});
const ClassSchema = new Schema({
location: { type: mongoose.Schema.Types.ObjectId, ref: 'Location' },
instructors: [{ type: mongoose.Schema.T
浏览 0提问于2016-03-02得票数 11
回答已采纳
这是我的MongoDB模式：
var partnerSchema = new mongoose.Schema({
name: String,
products: [
{
type: mongoose.Schema.Types.ObjectId,
ref: 'Product'
}]
});
var productSchema = new mongoose.Schema({
name: String,
campaign: [
{
浏览 0提问于2016-06-24得票数 5
回答已采纳
我不确定如何填充下面的示例模式，也不确定它是否可行。引用可以在如下所示的对象中吗？如果可以，您将如何填充它？例如，.populate('map_data.location');？
var sampleSchema = new Schema({
name: String,
map_data: [{
location: {type: Schema.Types.ObjectId, ref: 'location'},
count: Number
}]
});
或者我必须使用两个单独的数组来定位和计数，如下所示：
// Locations an
浏览 1提问于2013-01-30得票数 25
回答已采纳
2回答
这是我的游戏模式：
var mongoose = require('mongoose');
const GameSchema = new mongoose.Schema({
title: {
type: String,
required: true
},
publishers: [
{
type: mongoose.Schema.Types.ObjectId,
ref: 'Publisher'
}
]
});
va
浏览 14提问于2019-07-15得票数 0
回答已采纳
1回答
在花了一天时间做完事情后，我想是时候寻求帮助了。
我想填充文档的两个级别。
我尝试了populate()，但它似乎只适用于第一级，而不是深度填充！我读了很多书，我知道它应该有用，但我想我错过了一些很愚蠢的东西.
请告诉我我在哪里出错。
这是相关代码。
模式
var compositionSchema = new Schema({
name: {
type: String,
required: true
},
contributions: [{
type: Schema.Types.ObjectId,
ref
浏览 2提问于2017-10-17得票数 1
回答已采纳
1回答
我正在编写一个应用程序，以跟踪成员和他们的认证。每个成员都有一些数组，这些数组引用中描述的其他模型。
Member模式
{
name: {
first: String,
last: String
},
unit: Number,
// more stuff
class_year: Number,
campus_box: String,
campus_address: String,
// more stuff
emails: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Emai
浏览 3提问于2013-08-05得票数 0
回答已采纳
我有一个猫鼬模式定义为
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var userSchema = new Schema({
user_id: String,
event_organizer: [String],
});
module.exports = mongoose.model('User',userSchema);
现在，我有一个函数，希望将这个用户的Id添加到一个事件中。当然，这个事件已经出现在DB中了。
function addUserToE
浏览 2提问于2017-04-24得票数 1
回答已采纳
2回答
猫鼬多深度种群
、、、
比方说，我有Manager模式：
{
name: { type: String },
clients: [{ type: Mongoose.Schema.ObjectId, ref: 'Client'}]
}
而且，我有Client模式：
{
name : { type String },
cars : [{ type: Mongoose.Schema.ObjectId, ref: 'Car' }],
houses: [{ type: Mongoose.Schema.ObjectId, ref: 'House&
浏览 4提问于2017-09-01得票数 9
回答已采纳
我试图用模式中的信息填充节点快速路由，但不断收到此错误。我不能理解的是，我在同一个Schema中引用了三个不同的字段，并且由于某些原因，我只在其中一个字段中得到了这个错误。
这是我的路由函数，在这里我得到"MissingSchemaError: Schema尚未为模型“completed_by_user”注册“
// Schemas
const Transaction = require ("../models/transaction");
User = require ("../models/user");
Ticket
浏览 3提问于2020-05-26得票数 1
2回答
如何在Sub文档中填充ref文档，这是我的模式：
var person = mongoose.Schema({
name: { type: [String], index: true },
career: [{
position: { type: mongoose.Schema.Types.ObjectId, ref: 'Orgchart' }
}]
};
var orgchart = mongoose.Schema({
name: { type: [String], index: true },
};
我试过这部分：
浏览 1提问于2015-10-03得票数 2
回答已采纳
1回答
我有一个Schedule模式，我正在尝试从嵌套的slotsPerDay数组中创建一个元素。
const scheduleSchema = mongoose.Schema({
course_id: {{type: mongoose.Schema.Types.ObjectId, ref: 'course' }},
week_schedule: [{
day: {type: String, required: true },
slotsPerDay: [{type: mongoose.Schema.Types.ObjectId, r
浏览 3提问于2020-12-22得票数 0
回答已采纳
1回答
在猫鼬中填充虚拟场
、、、
我目前正在构建一个记录扑克统计数据的应用程序。用户创建玩家，然后用这些玩家填充游戏。
我有一个游戏模型，它引用了玩家模型中的玩家：
const gameSchema = new mongoose.Schema({
firstPlace: { type: mongoose.Schema.ObjectId, ref: 'Players', required: true },
secondPlace: { type: mongoose.Schema.ObjectId,ref: 'Players', required: true },
thirdPlace:
浏览 6提问于2022-07-30得票数 0
1回答
嗨，我试着在猫鼬中多次使用同一个列名，但是它显示了不同的output.Instead，我需要预期的输出，有任何方法可以实现it.Can，任何人都可以帮助我
const mongoose = require('mongoose')
mongoose.connect('----------------------------------------------',
{useNewUrlParser:true,useCreateIndex:true,useUnifiedTopology:true})
const wavicle = mongoose.model(&#
浏览 2提问于2020-07-07得票数 0
回答已采纳
1回答
参考文档属性中的猫鼬查找
、、、、
我将在查询中疯狂地寻找基于引用的文档属性的匹配。我已经像这样定义了我的模式：
mongoose.model('Route', new mongoose.Schema({
user: {
type: mongoose.Schema.Types.ObjectId,
ref: 'User'
}
}));
mongoose.model('Match', new mongoose.Schema({
route: {
type: mongoose.Schema.Types.Object
浏览 2提问于2014-07-02得票数 2
回答已采纳
1回答
在nodejs的post路由中，我将猫鼬模型对象保存到一个数组中，现在我想将该数组保存到mongodb中，为了做到这一点，我需要调用array.save()方法，该方法是在方法中内置的。为此，我需要将该数组转换为Mongoose模型类型，在本例中为Form。请说明如何应用此转换，或者是否需要任何其他解决方案？Mongoose模式是：
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var formSchema = new Schema({
controlType: {t
浏览 2提问于2017-11-16得票数 0
回答已采纳
2回答
我已经把我的项目作为一个对象数组在我的数据库中的集合中。现在我注意到每次服务器重新启动时都会添加这些项，结果是6而不是3种产品。如何检查数据库，以确定集合中是否已经存在某项，以避免重复？目前我得到的是“ReferenceError: title还没有定义”
Product.js (模型)
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const ProductSchema = new Schema({
product_id: {
type: String,
浏览 1提问于2018-10-15得票数 0
回答已采纳
请看下面的示例模式。
const ParentSchema = new mongoose.Schema({
id:String
name:String
age:Number
child:[{
id:String,
name:String,
age:Number}]
})
const collectionName = mongoose.model("parent", ParentSchema)
现在我想提高孩子和父母的年龄，因为他们每个人的特定身份。两者同时进行。我试着用下面的查询来完成它
浏览 2提问于2017-05-17得票数 2
回答已采纳
3回答
这是我的mongoose的question.js和user.js模式模型，谁能帮助我用Node填充likes:[]数组对象中的所有用户名列表，因为我几乎两周前就遇到了这个问题，我无法从likes中的用户填充用户名。我很感谢你的建议。
浏览 33提问于2020-02-04得票数 0
回答已采纳
我是初学者，有人能告诉我为什么我们需要将整个模式作为数组导入到一个新的模式对象中吗？这是什么目的？
页面: nestedSchema
如果我有
role_name: {
type: String,
},
pages: {
type: [nestedSchema],
},
});
const nestedSchema = new mongoose.Schema({
page_id: {
type: mongoose.Schema.Types.ObjectId,
ref: "page",
required: tr
浏览 9提问于2022-09-13得票数 0
回答已采纳
1回答
猫鼬重复索引
、、
我使用数组来存储ObjectId的，但是即使是重复的Id也被保存了
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const as = new Schema({
aId: [{
type: Schema.Types.ObjectId,
ref: 'js',
}],
jId: {
type: Schema.Types.ObjectId,
浏览 1提问于2017-01-20得票数 0
回答已采纳
我正在尝试使用ExpressJS和Mongoose更新子文档。但仅限于更改的字段。但不知何故，它更新了所有必要的字段，但也更新了不需要更改的字段。 这是ExpressJS中的更新函数： postController.updateMessage = function(req, res, item) {
var id = req.body.id;
var saveData = {
title: req.body.title,
text: req.body.text,
title_double: req.body.title_double,
text_dou
浏览 6提问于2019-01-31得票数 0
我正在尝试在一个用户数组中查找一个用户，该用户的id与我的令牌中的用户id相同，并且访问权限大于1。 为此，我使用了以下代码，但我得到了一个CastError： Project.findOne({ Users: {User: decoded._id, access: { $gte: authStatus }}, _id: id })
.then((result) => {
console.log(result)
})
.catch((err) => {
console.log(err)
浏览 41提问于2020-11-27得票数 1
回答已采纳
1回答
如何在列表中填充索引？假设我有以下模式
const supplierSchema = new mongoose.Schema({
name: String,
address: String,
size: Number,
... (19 other fields)
supplier_id: mongoose.Schema.Types.ObjectId,
});
const itemsSchema = new mongoose.Schema({
name: String,
date_time: {type: Date, default: D
浏览 7提问于2022-05-18得票数 0
2回答
我的Mongo数据库中有两个模型，例如Child和Parent。我会将多个子节点分配给一个父节点。它们基本上是这样定义的：
childSchema = new mongoose.Schema({
// fields
});
parentSchema = new mongoose.Schema({
// fields
ones: [{
type: mongoose.Schema.ObjectId,
ref: 'Child'
}]
});
我已经让它工作了，我可以将多个Child保存到一个Parent中，所有的东西都
浏览 2提问于2017-07-01得票数 1
我有一个包含数组字段("array")的集合，该集合存储引用另一个集合的_ids。我使用的是mongoose的.populate，可以使用字符串点表示法填充特定的数组元素，例如
.populate({path: "array.4"})
但现在我想填充数组的最后一个元素。在理想情况下，"array.-1"可以工作，但它不能。我尝试使用populate的match属性，如下所示：
.populate({
path: "array",
match: {
$arrayElemAt: {
$subtract:
浏览 2提问于2021-01-30得票数 1
3回答
似乎有很多关于堆叠溢出的问题，但我似乎在任何地方都找不到确切的答案。
我拥有的：
我有公司和个人模特：
var mongoose = require('mongoose');
var PersonSchema = new mongoose.Schema{
name: String,
lastname: String};
// company has a reference to Person
var CompanySchema = new mongoose.Schema{
浏览 2提问于2013-10-15得票数 31
回答已采纳
1回答
-在底部回答--
我和我的项目合作伙伴正在努力弄清楚如何访问数组中的对象，即MongoDB数据库中的文档中的对象。
我们正在构建一个网站，用户可以在其中创建一个作业(在特定的课程中)，在创建该作业之后，可以导航到该课程的主页，并访问该作业的页面(这将是一个通用的.ejs模板页面，根据我们创建的作业填充适当的信息)。
例如，在课程CS 212中，我们创建了作业1(包含几个问题和答案)和作业2。我们导航到CS 212的页面，点击作业1，它应该显示这些问题和答案。
我们希望使用我们在数据库中创建的赋值ID访问赋值的数据库数据，但是，"Courses.findOne( {赋值: assignm
浏览 5提问于2021-12-20得票数 0
回答已采纳
1回答
在模式(子文档)中嵌套模式与创建两个单独的模型和引用它们之间有什么区别，它们的性能如何？
子文档：
const postSchema = new Schema({
title: String,
content: String
});
const userSchema = new Schema({
name: String,
posts: [postSchema]
});
module.export = mongoose.model('User', userSchema);
嵌套模型(参照填充)：
const postSchema = new Schema({
浏览 3提问于2017-02-17得票数 16
我在我的MongoDB应用程序中使用mongoose定义了一个NodeJS模型，如下所示：
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const userSchema = new Schema({
name: {
type: String,
required: true
},
email: {
type: String,
required: true
},
password: {
type: String,
required: t
浏览 3提问于2022-08-02得票数 0
1回答
在我的猫鼬模型中，我有这样一个用户模式：
var userSchema = mongoose.Schema({
_id : String,
username: String,
name : String,
timestamp : { type : Date, default: Date.now },
admin : Boolean,
pages : [String]
});
var User = mongoose.model('User', userSchema);
我试图从这样的文档中获取页面数组：
function isUserPage(userId, pageId, ca
浏览 3提问于2013-08-27得票数 1
回答已采纳
var mongoose = require("mongoose");
// schema setup
var productSchema = new mongoose.Schema({
type:{
type:String,
required:[true,'a product must have a type']
},
sId:String,
image:String,
products:[{
浏览 46提问于2020-11-03得票数 0
我有两个MongoDB集合-注释
var mongoose = require('mongoose');
var CommentSchema = new mongoose.Schema({
body: String,
author: String,
upvotes: {type: Number, default: 0},
post: { type: mongoose.Schema.Types.ObjectId, ref: 'Profile' }
});
mongoose.model('Comment', CommentSche
浏览 2提问于2015-07-06得票数 2
回答已采纳
我想在用户模式中填充的字段(viewed_posts)：
viewed_posts: [
{
type: mongoose.Schema.Types.ObjectId,
ref: "Viewed"
}
]
查看模式：
var viewedSchema = new mongoose.Schema({
hitsByUser: {type: Number, default: 0},
viewsByUser: {type: Number, default: 0},
post: {
type: mongoo
浏览 1提问于2020-11-01得票数 0
回答已采纳
2回答
我使用的是猫鼬5.9.28和节点v12.16.1。
我需要编写一个函数，它将一个列表作为param，并在猫鼬模型中填充该列表。(模型在功能上是常数的)
我的模式：
var schema = new mongoose.Schema({
id : {
type : String,
required : true,
unique : true,
},
driverId : {
type : mongoose.Schema.Types.ObjectId,
ref : "drivers
浏览 3提问于2020-09-07得票数 0
回答已采纳
2回答
我试图在预“查找”中间件中为用户文档指定应该始终填充的字段，如下所示：
userSchema.pre(/^find/, function (next) {
this.populate("followers following"); next();
});
下面是用户模式：
const userSchema = new mongoose.Schema<IUser>(
{
firstName: {
type: String,
required: [true, "You must provide your first nam
浏览 6提问于2021-12-11得票数 0
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频
腾讯云开发者
