Mongodb 猫鼬。查找返回对象&；数组，导致兼容性问题

当用户访问我的应用程序的某个页面时，组件会发送一个操作来获取信息。即，该操作执行以下操作：

Base.find({req.params.id})
BaseUser.find({ baseId: req.params.id }) **returns multiple docs**
Message.find({ baseId: req.params.id }) **returns multiple docs**

操作按此顺序进行。我可以通过.findById查询第一个，但为了问题的一致性，我选择了

.find（）

。现在的问题是

    Promise.all([
      Base.find({ _id: req.params.id }),
      BaseUser.find({ baseId: req.params.id }),
      Message.find({ baseId: req.params.id })
    ])

以数组形式出现，如下所示：

[ 
  [ { created: 2018-08-29T23:59:35.380Z,
      _id: 5b8741151985662f10d04fdb,
      creatorId: 5b86f7970cd98b2004969bf0,
      title: 'testBase1',
  } ],
  [ { created: 2018-08-30T00:57:57.764Z,
      acceptedMembership: true,
      isCreator: true,
      _id: 5b8741151985662f10d04fdc,
      userId: 'tester1',
      baseId: 5b8741151985662f10d04fdb }
  ],
  [ { created: 2018-08-30T00:58:09.182Z,
      _id: 5b8741211985662f10d04fdd,
      baseId: 5b8741151985662f10d04fdb,
      content: 'testMessage1' } 
  ] 
]

当进一步尝试映射数据的/filter/res.json（）时，这显然会导致问题。是否有任何已知的方法可以在单个数组中返回它，或者更好地将它作为对象传递给前端（redux操作）？有人知道更好的解决方案吗？它可以稍微不同地处理这个问题，并阻止我在子组件上获取这些方法中的每一个

更新：

我现在构建了这个，看起来相当丑陋：

let completeObject = {
    base: {},
    users: [],
    messages: []
};

Base.findById(req.params.id)
    .then(data => {
        completeObject.base = data;
        return data;
    })
    .then(data => {
        BaseUser.find({ baseId: req.params.id })
            .then(data => {
                completeObject.users = data;
                return data;
            })
            .then(data => {
                Message.find({ baseId: req.params.id }).then(data => {
                    completeObject.messages = data;
                    return res.json(completeObject);
                });
            });
    })

---

为什么不在

Base

模型中将

ref

设置为

BaseUser

和

Message

，然后使用填充这些数组并获得一个对象，结果填充了BaseUser和Message的数组

从我看到的情况来看，您键入了

req.params.id

，这意味着您在这些集合之间有一个交叉引用

以下是一个例子：

var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var BaseSchema = Schema({
  _id: Schema.Types.ObjectId,
  creatorId: Schema.Types.ObjectId,
  title: String,    
  users: [{ type: Schema.Types.ObjectId, ref: 'User' }],
  messages: [{ type: Schema.Types.ObjectId, ref: 'Message' }],

});
var UserSchema = Schema({
  _id: Schema.Types.ObjectId,
  acceptedMembership: Boolean,
  isCreator: Boolean,
  userId: String,
  baseId: Schema.Types.ObjectId
});
var MessageSchema = Schema({
  _id: Schema.Types.ObjectId,
  baseId: Schema.Types.ObjectId,
  content: String
});

var Base = mongoose.model('Base', BaseSchema);
var User = mongoose.model('User', UserSchema);
var Message = mongoose.model('Message', MessageSchema);

既然模式已经定义（并且您添加了一些记录），您就可以通过

\u id

找到

基

，并填充

用户

和

消息

：

Base.
  findOne({ _id: req.params.id }).
  populate('users').
  populate('messages').
  exec(function (err, base) {
    if (err) return handleError(err);
    console.log(base);
  });

---

您应该查看mongoose文档，了解如何查找/引用等。

为什么不使用

findOne

而不是

find

？哇。。我不敢相信，所以我现在正把头撞在墙上。为了增加你的答案的合法性，你能告诉我你在文档中的确切位置，解释这些方法如何有不同的返回（例如数组和对象返回）？您应该在这里使用

async wait

和一些聚合技巧如果您使用的是mongodb 3.6，那么您可以尝试类似于我今天读到的

ref

和

populate

的内容。你有上面的例子吗？添加了更多信息。希望这能给你一个想法。这样，您将只获得1个文档（对象），并且在其中您将有一个

用户数组

作为属性，一个

消息数组

作为另一个属性。