express中条件筛选无限极分类，以角色筛选为例（附基本无限极分类查询例子）

Schema结构

用户信息

let userSchema=new Schema(
    {
        username:String,//用户名
        pwd:String, //密码
        roleid:{  //关联的角色菜单合集
            type:mongoose.Types.ObjectId,
            ref:"role"
        }
    }
)

角色管理 

let roleSchema = new Schema({
    name:String,  //角色名称
    menuid:{ //关联菜单合集
        type:[mongoose.Types.ObjectId],  //数组中以对象形式存入
        ref:"menu"  
    }
}) 

菜单分类

let menuSchema = new Schema({
    name:String, //菜单名称
    level:Number, //分类等级
    url:String, //用于页面跳转
    pid:{  //进行自关联
        type:mongoose.Types.ObjectId,
        ref:"menu"
    }
})

路由文件

Tips：

* 需要对查询结果进行二次操作时，要加上.lean（）方法

*进行_id判断时，因为mongoose中的id是对象类型，无法直接进行判断，所以要转为字符串类型，在这里直接使用了String()方法

*与基本类型不同的是条件筛选，要注意代码查询的先后顺序

代码示例：

router.get('/index', async (req, res) => {
//获取前端发送过来的userid，根据id判断登录的身份
  let userid = req.query.id
  let menulist = await menuModel.find().lean() //获取所有菜单列表，以便条件筛选
  let list = []    //定义大列表
  let rolelist=[] //定义角色菜单列表
  //定义一个对象  该对象的键是某个分类数据的 _id 值，值是这条_id对应的对象
  let obj = {}
  menulist.forEach((item) => {
    obj[item._id] = item
  })
  //定义一个存放无限极分类结果的数组
  let All_list=[]
  //遍历所有分类数据  找到一级分类 存入到list数组中
  menulist.forEach((item) => {
    if(!item["pid"]){
      //判断是否是一级分类  把一级存进去
      All_list.push(item)
    }else{
      //不是一级分类  需要查找当前分类数据的父级对象 ，判断该父级对象是否含有children属性 如果没有就定义一个children属性
      if(!obj[item["pid"]]["children"]){
        obj[item["pid"]]["children"]=[]
      }
      //将当前的分类数据 存入到父级的children属性中
      obj[item["pid"]]["children"].push(item)
    }
  })  

  if(userid){ //根据前端返回的角色ID，查询该角色包含的功能菜单数组
    let op = await userModel.find({
      _id: userid
    })  
    let roleid = op[0].roleid
    let rolelist = await roleModel.find({
      _id: roleid
    }).lean()  
     // menulist的id
  let ids = rolelist[0].menuid
  ids.forEach((id) => {
    menulist.forEach((item) => {
      if (String(id) === String(item._id)) {
        list.push(item)
      }
    })
  })
//在大列表和角色菜单列表中筛选出符合条件的功能，添加到角色列表中
    list.forEach((item)=>{
      All_list.forEach((ele)=>{
        if( String(item._id) === String(ele._id)){
          rolelist.push(ele)
        }
      })   
    })
  }

  res.send({
    code:200,
    msg:"okk",
    All_list,
    rolelist
  })
});

———————————基本类型无限极分类查询————————————

Schema

const categorySchema = new mongoose.Schema({
    name: String,
    level: Number,
    pid: {
     type: mongoose.Types.ObjectId,
     ref:"category",
    }
   
})

API接口

//无限极分类查询 商品分类数据
router.get("/infinite_list", async (req, res) => {
  let catelist = await categoryModel.find().lean()
  //定义一个对象  该对象的键是某个分类数据的 _id 值，值是这条_id对应的对象
  let cateObj = {}
  catelist.forEach((item) => {
    cateObj[item._id] = item
  })

  //定义一个存放无限极分类结果的数组
  let list = []

  //遍历所有分类数据  找到一级分类 存入到list数组中
  catelist.forEach((item) => {
    if (!item["pid"]) {
      //判断是否是一级分类  把一级存进去
      list.push(item)
    } else {
      //不是一级分类  需要查找当前分类数据的父级对象 ，判断该父级对象是否含有children属性 如果没有就定义一个children属性
      if (!cateObj[item["pid"]]["children"]) {
        cateObj[item["pid"]]["children"] = []
      }

      //将当前的分类数据 存入到父级的children属性中
      cateObj[item["pid"]]["children"].push(item)
    }
  })

  res.send({
    cateObj,
    list,
  })
})