NodeJs+mongoose实现搜索功能

模型层(search.model.js)

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

var UpshortSchema = new Schema({
    "ulid":{type:String},
    "pname":{type:String},
    "pintro":{type:String},
    "collected":{type:Number},
    "visited":{type:Number},
    "num":{type:Number},
    "author":{type:String},
    "created":{type:Number},
    "label":{type:Array},
    "level":{type:Number},
    "hash":{type:String},
    "exist":{type:Boolean},
})

module.exports = mongoose.model('Upshortinfo',UpshortSchema);

服务层(search.service.js)

const Upshortinfos = require('./search.model');

module.exports = {
    sear_user,
    sear_title,
    sear_label
}

// 以发布题集的用户名为搜索条件
async function sear_user(keyword,maxvalue,minvalue,sort,sortype) {
    let reg = new RegExp(keyword,'i');
    let params = {
        created:{
            $gte:minvalue,
            $lte:maxvalue
        },
        author:{$regex:reg}
    }; 
    let model = Upshortinfos.find(params);
    if(sortype){
        model.sort({'created':sort});
    }else{
        model.sort({'collected':sort});
    }
    try {
        let ret = await new Promise((resolve,reject)=>{
            model.exec(function(err,doc){
                if(err){
                    reject('fail to find set by author:'+keyword);
                }else{
                    if(!doc.length){
                        reject('the result is empty search by author:'+keyword);
                    }else{
                        resolve(doc);
                    }
                }
            });
        });
        return ret;
    } catch (error) {
        throw err;//从async模块中抛出错误
    }    
 }

//以题集标题为搜索条件
async function sear_title(keyword,maxvalue,minvalue,sort,sortype) { 
    let reg = new RegExp(keyword,'i');
    let params = {
        created:{
            $gte:minvalue,
            $lte:maxvalue
        },
        pname:{$regex:reg}
    }; 
    let model = Upshortinfos.find(params);
    if(sortype){
        model.sort({'created':sort});
    }else{
        model.sort({'collected':sort});
    }
    try {
        let ret = await new Promise((resolve,reject)=>{
            model.exec(function(err,doc){
                if(err){
                    reject('fail to find set by title:'+keyword);
                }else{
                    if(!doc.length){
                        reject('the result is empty search by title:'+keyword);
                    }else{
                        resolve(doc);
                    }
                }
            });
        });
        return ret;
    } catch (error) {
        throw err;//从async模块中抛出错误
    }  
 }

 //以题集标签为搜索条件
 async function sear_label(keyword,maxvalue,minvalue,sortype,sort) { 
    let reg = new RegExp(keyword,'i');
    let params = {
        created:{
            $gte:minvalue,
            $lte:maxvalue
        },
        label:{$regex:reg}
    }; 
    let model = Upshortinfos.find(params);
    if(sortype){
        model.sort({'created':sort});
    }else{
        model.sort({'collected':sort});
    }
    try {
        let ret = await new Promise((resolve,reject)=>{
            model.exec(function(err,doc){
                if(err){
                    reject('fail to find set by label:'+keyword);
                }else{
                    if(!doc.length){
                        reject('the result is empty search by label:'+keyword);
                    }else{
                        resolve(doc);
                    }
                }
            });
        });
        return ret;
    } catch (error) {
        throw err;//从async模块中抛出错误
    }
 }

控制层(search.controller.js)

const express = require('express');
const router = express.Router();
const qs = require("qs");
const searchService  = require('./search.service')


router.get('/', search);

function search(req, res, next){
    let params = qs.parse(req.query);
    let type = params.type;//查询关键字
    let keyword = params.keyword;//查询关键字
    let maxvalue = parseFloat(params.ceil);//查询范围上限，属性为时间
    let minvalue = parseFloat(params.floor);//查询范围下限
    let sortype = parseInt(params.sortype);//排序方式
    let sort = parseInt(params.sort);//搜索结果是否按时间进行排序
    console.log(`${type} ${keyword} ${maxvalue} ${minvalue} ${sort}`);
    switch(type){
        case 'user':
            searchService.sear_user(keyword,maxvalue,minvalue,sort,sortype).then((data)=>{
                res.json({status:0,msg:'successful to find set',result:data});
            }).catch((err)=>{
                res.json({status:1,msg:err,result:''});
            })
            break;
        case 'title':
            searchService.sear_title(keyword,maxvalue,minvalue,sort,sortype).then((data)=>{
                console.log(data);
                res.json({status:0,msg:'successful to find set',result:data});
            }).catch((err)=>{
                res.json({status:1,msg:err,result:''});
            })
            break;
        case 'label':
            searchService.sear_label(keyword,maxvalue,minvalue,sort,sortype).then((data)=>{
                console.log(data);
                res.json({status:0,msg:'successful to find set',result:data});
            }).catch((err)=>{
                res.json({status:1,msg:err,result:''});
            })
            break;
        default:(function(){
            res.json({status:'1',msg:'please choose search type!',result:''});
        })();
    }
}

module.exports = router;

注：一定要注意项目的分层结构，要不然后面真的很难搞