MongoDB-sort()&mongoose

Mongodb

sort()和投影

  • //查询文档时,默认情况是按照_id的值进行排列(升序)
    //sort()可以用来指定文档的排序的规则,sort()需要传递一个对象来指定排序规则 1表示升序 -1表示降序
    //limit skip sort 可以以任意的顺序进行调用
    db.emp.find({}).sort({sal:1,empno:-1});
    
    //在查询时,可以在第二个参数的位置来设置查询结果的 投影
    db.emp.find({},{ename:1 , _id:0 , sal:1});
    

mongoose

  • MongoDB-sort()&mongoose
  • mongoose的好处
    • 可以为文档创建一个模式结构(Schema)
    • 可以对模型中的对象/文档进行验证
    • 数据可以通过类型转换转换为对象模型
    • 可以使用中间件来应用业务逻辑挂钩
    • 比Node原生的MongoDB驱动更容易
  • 新的对象
    • Schema(模式对象)
    • Schema对象定义约束了数据库中的文档结构
    • Model
    • Model对象作为集合中的所有文档的表示,相当于 MongoDB数据库中的集合collection
    • Document
    • Document表示集合中的具体文档,相当于集合中 的一个具体的文档
    • 注意: 创建也是有顺序的 现有Schema再有Medel然后Document

Schema和Model

            如何在WebStorm中连接数据库并与数据库进行交互

  • 1.下载安装Mongoose
    npm i mongoose --save

  • 2.在项目中引入mongoose
    var mongoose=require(“mongoose”);

  • 3.连接MongoDB数据库

     mongoose.connect(‘mongodb://数据库的ip地址:端口号/数据库名’, { useMongoClient: true});

        如果端口号是默认端口号(27017) 则可以省略不写
       mongoose.connect(“mongodb://127.0.0.1/my_test”,{ useNewUrlParser: true });
      在我这里不需要添加{ useMongoClient: true}而是需要{ useNewUrlParser: true }

  • 4.断开数据库连接(一般不需要调用)

    ​    MongoDB数据库,一般情况下,只需要连接一次,连接一次以后,除非项目停止服务器关闭,否则连接一般不会断开
      mongoose.disconnect()

  • 监听MongoDB数据库的连接状态
      在mongoose对象中,有一个属性叫做connection,该对象表示的就是数据库连接
      通过监视该对象的状态,可以来监听数据库的连接与断开

    • 数据库连接成功的事件
      mongoose.connection.once(“open”,function(){});

    • 数据库断开的事件
      mongoose.connection.once(“close”,function(){});

    • //引入
      var mongoose=require("mongoose");
      //链接数据库
      mongoose.connect("mongodb://127.0.0.1/my_test",{ useNewUrlParser: true });
      mongoose.connection.once("open",function () {
          console.log("数据库连接成功")
      });
      mongoose.connection.once("close",function () {
          console.log("数据库断开成功")
      });
      //断开数据库连接
      mongoose.disconnect();
      
  • 向数据库中插入记录

    • var mongoose=require("mongoose");
      mongoose.connect("mongodb://127.0.0.1/my_test",{ useNewUrlParser: true });
      mongoose.connection.once("open",function () {
          console.log("数据库连接成功");
      });
      //将mongoose.Schema赋值给一个变量
      var Schema=mongoose.Schema;
      
      //创建Schema(模式)对象
      var stuSchema=new Schema({
          name:String,
          age:Number,
          gender: {
              type:String,
              default:"female",
          },
          address:String
      });
      //通过Schema来创建Model
      //Model代表的是数据库中的集合,通过Model才能对数据库进行操作
      //mongoose.model(modelName,schema);
      //modelName就是要映射的集合名
      var StuModel=mongoose.model("student",stuSchema);
                          //这里的modelName如果是单数,那么在Mongodb中自动变为复数。如果是复数就不变
      
      //像数据库中插入一个文档
      //StuModel.create(doc,function(err){})
      StuModel.create(
          {
              name:"标枪",
              age:12,
              gender:"female",
              address:"碧蓝航线"
          },function (err) {
              if(!err){
                  console.log("插入成功....");
              }
      });
      
    • 控制台提示

        数据库连接成功
        插入成功…

用Schema和Model进行增删改查

               有了Model,我们就可以来对数据库进行增删改查的操作了

  • 创建

    Model.create(doc(s), [callback])

    • 用来创建一个或多个文档并添加到数据库中

    • 参数:
      doc(s) 可以是一个文档对象,也可以是一个文档对象的数组
      callback 当操作完成以后调用的回调函数

    •    StuModel.create([
             {
                 name:"天津风",
                 age:12,
                 gender:"female",
                 address:"舰队"
             },{
                 name:"岛风",
                 age:12,
                 gender:"female",
                 address:"舰队"
             }
         ],function (err) {
             if(!err){
                 console.log("插入成功aaa");
             }
         });
      
  • 查询

    • Model.find(conditions, [projection], [options], [callback])

      • 查询所有符合条件的文档 总会返回一个数组
    • Model.findById(id, [projection], [options], [callback])*

      • 根据文档的id属性查询文档
    • Model.findOne([conditions], [projection], [options], [callback])

      • 查询符合条件的第一个文档 总和返回一个具体的文档对象

         conditions 查询的条件
          projection 投影 需要获取到的字段

      • 两种方式
        {name:1,_id:0}
        "name -_id"

        options 查询选项(skip limit)
        {skip:3 , limit:1}
        callback 回调函数,查询结果会通过回调函数返回
        回调函数必须传,如果不传回调函数,压根不会查询

      StuModel.find({name:"雪风"},function (err,docs) {
          if(!err){
              console.log(docs);
          }
      });
      
      StuModel.find({},function (err,docs) {
          if(!err){
              console.log(docs);
          }
      });//查询所有记录
      
      StuModel.find({},{name:1,_id:0},function (err,docs) {
          if(!err){
              console.log(docs);
          }
      });//投影  这个只要name 不要_id
      
      StuModel.find({},"name age -_id",function (err,docs) {
          if(!err){
              console.log(docs);
          }
      });//这种方法-->在字符串里出现的字段就会检索  加负号表示不会出现
      
      StuModel.find({},"name age -_id",{skip:5,limit:1},function (err,docs) {
          if(!err){
              console.log(docs);
          }
      });//skip 跳过5个   limit限制检索1个
      
      StuModel.findOne({},function (err,doc) {
          if(!err){
              console.log(doc);//返回一个具体的文档对象
              console.log(doc.name);//返回这个文档对象的name
          }
      });
      
      StuModel.findById("5d575a723ec5cf506c50cd69",function (err,doc) {
          if(!err){
              console.log(doc);//通过id查找对用的文档对象
              //通过find()查询的结果,返回的对象,就是通过Document文档对象
              //Document对象是Model的实例
              console.log(doc instanceof StuModel);//true
          }
      });
      
  • 修改

    • Model.update(conditions, doc, [options], [callback])
      Model.updateMany(conditions, doc, [options], [callback])
      Model.updateOne(conditions, doc, [options], [callback])

      • 用来修改一个或多个文档
      • 参数:
        conditions 查询条件
        doc 修改后的对象
        options 配置参数
        callback 回调函数

        Model.replaceOne(conditions, doc, [options], [callback])
    //修改天津风的年龄为13
    StuModel.updateOne({name:"天津风"},{$set:{age:13}},function (err) {
        if(!err){
            console.log("修改成功");
        }
    });
    
  • 删除

    • Model.remove(conditions, [callback])
      Model.deleteOne(conditions, [callback])
      Model.deleteMany(conditions, [callback]) 删除方法基本不用

    • StuModel.deleteOne({name:"岛风"},function (err) {
         if(!err){
             console.log("删除成功..");
         }
      });
      
  • 查询文档数量

    • Model.count(conditions, [callback])

      • 统计文档的数量的
    • StuModel.count({},function (err , count) {
          if(!err){
              console.log(count);
          }
      });//9
      

通过document对象的方法来操作数据库

  • MongoDB-sort()&mongoose

  • Document 和 集合中的文档一一对应 , Document是Model的实例
    通过Model查询到结果都是Document

    //创建一个Docuement
    var stu=new StuModel({
       name:"雷",
        age:10,
        gender:"female",
        address:"舰队"
    });
    
  • document的方法
    Model#save([options], [fn])

    stu.save(function (err) {
       if(!err) {
           console.log("保存成功...");
       }
    });
    
  • update(update,[options],[callback])

    修改对象
    remove([callback])

    删除对象

    StuModel.findOne({},function (err , doc) {
        if(!err){
            /*
                 update(update,[options],[callback])
                     - 修改对象
                 remove([callback])
                     - 删除对象
    
             */
            doc.updateOne({$set:{age:14}},function (err) {
                 if (!err) {
                    console.log("修改成功~~~");
                 }
             })
    
            //或这种方法
            doc.age=13;
            doc.save();
            
             doc.remove(function (err) {
                if(!err){
            	console.log("被选中的再见了");
                 }
             })
        }
    });     
    
  • get()
       获取文档中的指定属性值
    set()
       设置文档的指定属性值
    id
       获取文档的_id属性值
    toJSON()
       转换为一个JSON对象
    toObejct()
        将Document对象转换为一个普通的JS对象
       转换为普通的js对象以后,注意所有的Document对象的方法或属性都不能使用了

    StuModel.findOne({},function (err , doc) {
        if(!err){    
    		console.log(doc.get("name"));
            console.log(doc.age);
            doc.set("name","响");
            doc.name="响";
    
            console.log(doc._id);
                    var j=doc.toJSON();
                    console.log(typeof j);  //这个方法有问题 返回的是Object
            var o=doc.toObject();//转成一个普通的js对象
            doc=doc.toObject();//再转成document对象 才能执行删除的操作
            delete doc.address;
            console.log(doc);
        }
    });
    

mongoose的模块化

  • 创建一个Model文件夹专门放模型

    • /*
      定义Student模型
       */
      var mongoose=require("mongoose");
      var Schema=mongoose.Schema;
      var stuSchema=new Schema({
          name:String,
          age:Number,
          gender: {
              type:String,
              default:"female",
          },
          address:String
      });
      //定义模型
      var StuModel=mongoose.model("student",stuSchema);
      module.exports=StuModel;
      
  • 创建一个tools文件夹里面创建一个conn_mongo.js文件模块来连接数据库

    • /*
          定义一个模块,用来连接MongoDB数据库
       */
      var mongoose=require("mongoose");
      mongoose.connect("mongodb://127.0.0.1/my_test",{ useNewUrlParser: true });
      mongoose.connection.once("open",function () {
          console.log("数据库连接成功");
      });
      
  • index.jsp文件测试

    • require("./tools/conn_mongo");
      var Student=require("./Models/Student");
      Student.find({ },function (err,docs) {
         if(!err){
             console.log(docs);
         }
      });
      
上一篇:javascript – mongoose .find()方法返回带有不需要的属性的对象


下一篇:javascript-Node.js-从域模型抽象猫鼬模型