Question

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

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' } 
  ] 
]

当进一步尝试映射/过滤/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);
                });
            });
    })

Answer 1

为什么不将ref模型中的Base设置为BaseUser和Message，然后使用populate填充这些数组并得到一个对象是否填充了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);

现在定义了架构（并添加了一些记录），您可以通过Base找到_id并填充users和messages：

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

您应该查看猫鼬文档，了解如何save / populate参考等。

猫鼬.findById和.find返回对象和数组，导致兼容性问题

1 个答案: