Question

我有一个结构化的应用程序：index＆gt;路线＆gt;端点＆gt;核心，其中端点处理发送响应的请求，核心访问数据库。将控制器划分为这两个组件的部分原因是为了在数据库更改后使工作正常工作，并部分简化我的代码。问题是我只能通过回调在我的模块中获得mongoose查询函数的结果，这根本不会简化我的代码。
我想要的是什么：

var user = coreModule.findUser({id:123}) //return user
var posts = coreModule.findPosts({author:123}) //return posts array
res.render("home", {user:user, posts:posts})

通过做：

//core module example
findUser: function(params){
   User.findOne(params, function(err,docs){
      if(err){
         return err
      }else{
         return docs
      }
   }
}

但相反，我必须使用一堆回调函数，这些函数首先会破坏核心模块的一半用途。我已经看到你可以用SQL和Knex做到这一点，但它不适用于mongoose。如果我想做的事情是不可能的，那么在这种情况下会推荐一种猫鼬替代品吗？

Answer 1

使用Async / Await语法：

const findUser = async function (params) { 
    try {  return await User.findOne(params)
    } catch(err) { console.log(err) }
}

const userSteve = findUser({firstName: Steve})

每次需要使用查询中的信息时，请使用await函数中的async前缀。这将允许您在需要该查询结果的同步代码中使用Mongoose查询的异步特性。

代码：

coreModule.findUser  = async function (userId) { 
    return await User.findOne({id:_userId})
}

coreModule.findPosts = async function(authorId) {
    return await Posts.find({postedBy: authorId})
}

const foundUser = coreModule.findUser(123);
const foundPosts = coreModule.findPosts(123);
res.send({user: foundUser, posts: foundPosts})

如果您希望同时启动两个查询，可以使用Promise.all()

coreModule.findUser  =  function (userId) { 
    return User.findOne({id:_userId})
}

coreModule.findPosts = function(authorId) {
    return Posts.find({postedBy: authorId})
}

const [foundUser, foundPosts] = 
   await Promise.all(
         [coreModule.findUser(123), coreModule.findPosts(123)]
   ); 

res.send({user: foundUser, posts: foundPosts})

如果您的API中的两个查询位于不同的EndPoints，您还可以构建针对两个端点的两个获取请求，并使用Promise.all（）

在客户端同时触发这些请求。

我希望这有帮助！

编辑：我已经使用我在API中测试的这个工作示例编辑了我的帖子：

module.exports.test = async function(req, res, next) {
    const module1 = function(params) {
        return ShoppingCartModel.find({_id: params})
    }
    const module2 = function(params) {
        return User.find({_id: params})
    }
    const array = [module1('5a739dbc45424d2904faca5b'), module2('5a739dbc45524d2904faca5b')]
    const promise = await Promise.all(array)
    res.json(promise)
}

错误退货的一些例子：

不正确：

const array = [ShoppingCartModel.find({}), ShoppingCartModel.find({})]
// console.log(array) = Mongoose Query Constructors
const promise = Promise.all(array)
// console.log(promise) = Promise { <pending> }

正确：

const array = [ShoppingCartModel.find({}), ShoppingCartModel.find({})]
const promise = await Promise.all(array)

不正确：

// Return full fledged promise from Mongoose query using .exec()
const array = [ShoppingCartModel.find({}).exec(), ShoppingCartModel.find({}).exec()]
// console.log(array) = [ Promise { <pending> }, Promise { <pending> } ]
const promise = Promise.all(array)
// console.log(promise) = Promise { <pending> }

正确：

const array = [ShoppingCartModel.find({}).exec(), ShoppingCartModel.find({}).exec()]    
const promise = await Promise.all(array)

您必须等待Promise.all的结果，否则您的函数将通过函数调用，将空的JSON对象发送回前端，以及未给定时间的console.log挂起的promise解决

Answer 2

就调用db是异步事物而言，您必须以异步方式等待响应。但是，回调不是唯一的方法。您可以使用promises，并获得更清晰的代码。它看起来像这样：

coreModule.findUser({id:123})
.then(user => {
    return coreModule.findPosts({author:123});
})
.then(posts => {
    res.render("home", {user:user, posts:posts});
});

而猫鼬部分应该使用回调来响应承诺，如下所示：

//core module example
findUser: function(params){
   return User.findOne(params).lean(true).exec();
}

希望有所帮助

Answer 3

const findBook = async (queryParams) => { 
    try {  
         return await Book.findOne(params)
    } catch(error) { 
          // handle the errors
  }
}

const getBook = async (req, res) =>{
    try{
     const book = findBook(queryParams);
     // next code goes here
    }catch(error){
          // handle the errors
    }
}

如何在没有回调的情况下返回Mongoose查询结果

3 个答案: