封装Nodejs的mongoose查询

封装Nodejs的mongoose查询

function  search(model,query,option,cb){


  var query = model.find(query);
  
  for(var op in option){
      
      query[op](option[p]);
      
  }

  query.exec(cb);

}
调用
search(BlogModel,{},{limit:10,sort:{ctime: -1}},function(err,data){


  console.log(data);

});

修改option就可以,都可以做成配置的文件来查


4 回复

当然可以！封装Mongoose 查询是一个很好的实践，因为它可以提高代码的可重用性和可维护性。下面我将对你的示例进行一些改进，并提供更详细的说明。

封装 Node.js 的 Mongoose 查询

目标

封装一个通用的查询函数，可以接受不同的参数，并且能够处理各种查询选项（如分页、排序等）。

示例代码

const mongoose = require('mongoose');

// 定义一个通用的查询函数
async function search(model, query, options) {
    // 创建查询对象
    let queryObj = model.find(query);

    // 处理分页参数
    if (options.limit) {
        queryObj = queryObj.limit(options.limit);
    }

    if (options.skip) {
        queryObj = queryObj.skip(options.skip);
    }

    // 处理排序参数
    if (options.sort) {
        queryObj = queryObj.sort(options.sort);
    }

    // 执行查询
    const data = await queryObj.exec();

    return data;
}

// 调用示例
search(BlogModel, {}, { limit: 10, sort: { ctime: -1 } })
    .then(data => {
        console.log(data);
    })
    .catch(err => {
        console.error(err);
    });

解释

  1. 函数定义：

    • search 函数接收三个参数：model（Mongoose 模型）、query（查询条件）和 options（查询选项）。

  2. 创建查询对象：

    • 使用 model.find(query) 创建一个基础查询对象。

  3. 处理分页参数：

    • 如果 options 中包含 limit 参数，则使用 queryObj.limit(options.limit) 进行分页限制。
    • 如果 options 中包含 skip 参数，则使用 queryObj.skip(options.skip) 进行跳过记录。

  4. 处理排序参数：

    • 如果 options 中包含 sort 参数，则使用 queryObj.sort(options.sort) 进行排序。

  5. 执行查询：

    • 使用 await queryObj.exec() 执行查询并获取结果数据。

  6. 调用示例：

    • 在调用 search 函数时，传入 BlogModel 模型、空查询条件 {} 和包含分页和排序参数的对象 { limit: 10, sort: { ctime: -1 } }。
    • 使用 .then 和 .catch 来处理异步操作的结果和错误。

通过这种方式，你可以轻松地扩展查询功能，例如添加更多的查询选项或处理复杂的查询逻辑。希望这对你有所帮助！


怎么样给所有的model类都加上这个方法呢?

做一个工厂：

function factory(modelName){ 
  var model = db.model(modelName); 
  model.search = function(){}; 
  return model; 
}

或者像JQuery一样：

//初始化程序时运行
(function(){
  var mongoose = require('mongoose');
  mongoose.Model.prototype.search = function(){};
})();

第二种没试过，你试一试看怎么样？

在Node.js中使用Mongoose进行数据库查询时，封装查询逻辑可以提高代码的可维护性和复用性。你提供的代码基本上是正确的，但有一些小问题需要修正。以下是改进后的版本，并附带一些注释来帮助理解。

改进后的代码

// 封装Mongoose查询函数
function search(model, query, options, cb) {
    // 创建查询对象
    let q = model.find(query);

    // 遍历options对象中的每个属性
    for (let key in options) {
        if (options.hasOwnProperty(key)) {
            // 确保options中的方法存在于Query原型上
            if (q[key]) {
                q[key](options[key]);
            } else {
                console.error(`Method ${key} is not available on Mongoose Query.`);
            }
        }
    }

    // 执行查询
    q.exec(cb);
}

// 调用search函数的例子
search(
    BlogModel,
    {}, // 查询条件
    { limit: 10, sort: { ctime: -1 } }, // 查询选项
    function (err, data) {
        if (err) {
            console.error('Error:', err);
        } else {
            console.log('Data:', data);
        }
    }
);

解释

  1. 函数定义：search 函数接受四个参数：模型（model）、查询条件（query）、查询选项（options）和回调函数（cb）。

  2. 创建查询对象：使用 model.find(query) 创建一个查询对象 q。

  3. 处理选项：遍历 options 对象，检查每个属性是否为查询对象的方法。如果是，则调用该方法并传递相应的值。如果不是，则打印错误信息。

  4. 执行查询：使用 .exec(cb) 执行查询，并传入回调函数来处理结果或错误。

  5. 调用示例：调用 search 函数时，传入 BlogModel 模型、空查询条件 {}、指定的查询选项 { limit: 10, sort: { ctime: -1 } } 和回调函数。

这样封装的查询函数使得在不同地方重用查询逻辑变得非常方便，同时也便于管理和扩展。

回到顶部