Mongoose学习全面理解(推荐)

一、创建schemas

创建schemas的方式：

 var userschema = new mongoose.schema({
   name: string,
   email: string,
   createdon: date
 });

schemas中的数据类型有以下几种：

•  string
•  number
•  date
•  boolean
•  buffer
•  objectid
•  mixed
•  array

特别需要说明一下objectid类型和mixed类型以及array类型，在schemas中声明这几种类型的方式如下：

//objectid就类似于唯一键值
projectschema.add({
  owner: mongoose.schema.types.objectid
});
//混合类型，顾名思义，就是说里面可以放置任意类型的数据，有两种方式创建该类型数据
//方式一：直接赋予一个空的字面量对象
vardjschema= new mongoose.schema({
  mixedup: {}
});
//方式二：根据schemas.types中值来赋予
vardjschema= new mongoose.schema({
  mixedup: schema.types.mixed
});
//array类型数据有两种创建方式，一种是简单数组创建：
var userschema = new mongoose.schema({
  name: string,
  emailaddresses: [string]
});
//第二种方式就是复杂类型数据数组，例如我们可以再数组中添加不同类型的schemas:
var emailschema = new mongoose.schema({
  email: string,
  verified: boolean
});
var userschema = new mongoose.schema({
  name: string,
  emailaddresses: [emailschema]
});
//注意：如果定义一个空的数据的话，则会创建为一个混合类型数据的数组：
var emailschema = new mongoose.schema({
  email: string,
  verified: boolean
});
var userschema = new mongoose.schema({
  name: string,
  emailaddresses: [emailschema]
});

我们可以给schema创建静态方法，这个静态方法将来会用在model中，创建该静态方法需要在创建完成schema之后，在model编译之前：

 projectschema.statics.findbyuserid = function (userid, callback) {
  this.find({ createdby: userid }, '_id projectname', {sort: 'modifiedon'}, callback);
 };

在其对应的模型创建完成并编译后，我们就可以像下面这样来调用该静态方法了：

model.findbyuserid(userid,callback);

该静态方法会返回一个json格式的数据，这在我们使用ajax技术来加载网页数据的时候会比较方便，就像下面这样：

//路由规则：app.get('/project/byuser/:userid', project.byuser);
exports.byuser = function (req, res) {
  console.log("getting user projects");
  if (req.params.userid){
    project.findbyuserid(req.params.userid,function (err, projects) {
      if(!err){
        console.log(projects);
        res.json(projects);
      }else{
        console.log(err);
        res.json({"status":"error", "error":"error finding projects"});
      }
    });
  }else{
    console.log("no user id supplied");
    res.json({"status":"error", "error":"no user id supplied"});
  }
};

二、创建model

创建model很简单：

mongoose.model('user', userschema);

参数一为model的名字，参数二为生成model所需要的schema,model就像是schema所编译而成的一样。

mongoose连接数据库是有两种方式的：

//方式一：
var dburi = 'mongodb://localhost/mydatabase';
mongoose.connect(dburi);
//方式二：
var dburi = 'mongodb://localhost/myadmindatabase';
var adminconnection = mongoose.createconnection(dburi);
//如果需要声明端口号：
var dburi = 'mongodb://localhost:27018/mydatabase';
//如果需要定义用户名和密码：
var dburi = 'mongodb://username:password@localhost/mydatabase';
//也可以像下面这样传一个对象类型的参数：
var dburi = 'mongodb://localhost/mydatabase';
var dboptions = {'user':'db_username','pass':'db_password'};
mongoose.connect(dburi, dboptions);

根据连接数据库的方式，我们可以得到第二种创建model的方式，就是使用数据库连接的引用名来创建：

adminconnection.model( 'user', userschema );

默认情况下mongoose会根据我们传入的model名字来生成collection名字，在上面的代码中就会生成名为users(全为小写字母)的collection(集合)；

有两种方法能让我们自定义collection的名字。

//方式一，在创建schema的时候定义collection的名字：
var userschema = new mongoose.schema({
  name: string,
  email: {type: string, unique:true}
},
{
  collection: 'myuserlist'
});
//方式二，在创建model的时候定义collection的名字：
mongoose.model( 'user', userschema, 'myuserlist' );

创建model实例：

var user = new user({ name: 'simon' });

user就是模型user的一个实例，它具有mongoose中模型所具有的一些方法，例如保存实例：

 user.save(function (err) {
   if (err) return handleerror(err);
 });

模型也具有一些常用的增删查改的方法：

user.findone({'name' : 'sally', function(err,user) {
  if(!err){
    console.log(user);
  }
});
user.find({}, function(err, users) {
  if(!err){
    console.log(users);
  }
});

可以使用链式方式使用这些方法，例如：

var newuser = new user({
  name: 'simon holmes',
  email: '[e-mail]',
  lastlogin : date.now()
}).save( function( err ){
  if(!err){
    console.log('user saved!');
  }
});

上面的代码创建了一个模型实例，然后进行保存。我们有一个更为简介的方式来完成这项工作，就是使用model.create()方法：

user.create({
  name: 'simon holmes',
  email: '[e-mail]',
  lastlogin : date.now()
}, function( err, user ){
  if(!err){
    console.log('user saved!');
    console.log('saved user name: ' + user.name);
    console.log('_id of saved user: ' + user._id);
  }
});

三、查找数据和读取数据的方法

1.使用querybuilder接口来查找数据

先看看下面的代码：

var myquery = user.find({'name' : 'simon holmes'});
myquery.where('age').gt(18);
myquery.sort('-lastlogin');
myquery.select('_id name email');
myquery.exec(function (err, users){
  if (!err){
    console.log(users); // output array of users found
  }
});

代码中，我们查找名字为"simon holmes"，并且年龄大于18岁，查找结果根据lastlogin降序排列，只获取其中的_id, name, email三个字段的值，上面的代码只有在调用exec方法后才真正执行数据库的查询。

当然我们可以使用链式的方式来改写上面的代码，代码会更加简洁：

user.find({'name' : 'simon holmes'})
.where('age').gt(18)
.sort('-lastlogin')
.select('_id name email')
.exec(function (err, users){
  if (!err){
    console.log(users); // output array of users found
  }
});

上面代码中的第一行创建了一个querybuilder.通过使用这个querybuilder，我们就可以执行一些比较复杂的查找工作，在创建完成这个querybuilder之后，查询操作并没有马上执行，而是待到执行exec方法时才会去执行数据库的查找。

当然也有另外一种方式能够直接查找数据库的，就是直接在查找方法中添加回调函数，使用方式为：

model.find(conditions, [fields], [options], [callback])

下面举一个简单例子：

 user.find({'name', 'simon holmes'}, function(err, user) {});

另一个稍微复杂的例子：

 user.find({'name', 'simon holmes'}, 'name email',function(err, user) {
   //console.log('some thing');
 });

另一个更加复杂的例子，包含查询结果的排序：

user.find({'name' : 'simon holmes'},
  null, // 如果使用null，则会返回所有的字段值
  {sort : {lastlogin : -1}}, // 降序排序
  function (err, users){
    if (!err){console.log(users);}
  });

列举几个比较实用的查找方法：

 model.find(query);
 model.findone(query);//返回查找到的所有实例的第一个
 model.findbyid(objectid);//根据objectid查找到唯一实例

例如：

 user.findone({'email' : req.body.email},
 '_id name email',
 function(err, user) {
   //todo
 });

 2.更新数据

有三种方式来更新数据：

(1)update(conditions,update,options,callback);

该方法会匹配到所查找的内容进行更新，不会返回数据；

(2)findoneandupdate(conditions,update,options,callback);

该方法会根据查找去更新数据库，另外也会返回查找到的并未改变的数据；

(3)findbyidandupdate(conditions,update,options,callback);

该方法跟上面的findoneandupdate方法功能一样，不过他是根据id来查找文档并更新的。

三个方法都包含四个参数，一下稍微说明一下几个参数的意思：

• conditions:查询条件
• update:更新的数据对象，是一个包含键值对的对象
• options:是一个声明操作类型的选项，这个参数在下面再详细介绍
• callback:回调函数

对于options参数，在update方法中和findoneandupdate、findbyidandupdate两个方法中的可选设置是不同的；

//在update方法中，options的可选设置为：
{
safe:true|false, //声明是否返回错误信息，默认true
upsert:false|true, //声明如果查询不到需要更新的数据项，是否需要新插入一条记录，默认false
multi:false|true, //声明是否可以同时更新多条记录，默认false
strict:true|false //声明更新的数据中是否可以包含在schema定义之外的字段数据，默认true
}
//对于findoneandupdate、findbyidandupdate这两个方法，他们的options可选设置项为：
{
new:true|false, //声明返回的数据时更新后的该是更新前的，如果为true则返回更新后的，默认true
upsert:false|trure, 
sort:javascriptobject, //如果查询返回多个文档记录，则可以进行排序，在这里是根据传入的javascript object对象进行排序
select:string //这里声明要返回的字段，值是一个字符串
}

下面举个例子：

 user.update({_id:user._id},{$set: {lastlogin: date.now()}},function(){});

3.数据删除

跟更新数据一样，也有三种方法给我们删除数据：

remove();
findoneandremove();
findbyidandremove();

remove方法有两种使用方式，一种是用在模型上，另一种是用在模型实例上，例如：

user.remove({ name : /simon/ } , function (err){
  if (!err){
    // 删除名字中包含simon的所有用户
  }
});

user.findone({ email : '[e-mail]'},function (err,user){
  if (!err){
    user.remove( function(err){
      // 删除匹配到该邮箱的第一个用户
    });
  }
});

接下来看一下findoneandremove方法：

user.findoneandremove({name : /simon/},{sort : 'lastlogin', select : 'name email'},function (err, user){
  if (!err) {
    console.log(user.name + " removed");
    // simon holmes removed
  };
});

另外一个findbyidandremove方法则是如出一辙的。

user.findbyidandremove(req.body._id,function (err, user) {
  if(err){
    console.log(err);
    return;
  }
  console.log("user deleted:", user);
});

四、数据验证

1.mongoose内置数据验证

在mongoose中，数据验证这一层是放在schema中的，mongoose已经帮我们做了很多内置的数据验证，有一些验证是针对某些数据类型的，也有一些是针对所有数据类型的。

能够作用在所有数据类型上的验证有require，意思就是该字段是否是必须的，例如：

email: { type: string, unique: true, required: true }

上面的代码就定义了一个email是必须的schema.

下面再分别介绍一下mongoose内置的一些数据验证类型。

数字类型schemastype,对于number类型的数据，具有min,max提供用来界定最大最小值：

 var teenschema = new schema({
   age : {type: number, min: 13, max:19}
 });

字符串类型schemastype,对于该类型数据，mongoose提供了两种验证器：

• match:可使用正则表达式来匹配字符串是否符合该正则表达式的规则
• enum:枚举出字符串可使用的一些值

分别举例如下：

var weekdayschema = new schema({
  day : {type: string, match: /^(mon|tues|wednes|thurs|fri)day$/i}
});

var weekdays = ['monday', 'tuesday', 'wednesday', 'thursday','friday'];
var weekdayschema = new schema({
  day : {type: string, enum: weekdays}
});

在我们进行一些数据库的时候，如果有错误，可能会返回一些错误信息，这些信息封装在一个对象中，该对象的数据格式大致如下：

{ 
  message: 'validation failed',
  name: 'validationerror',
  errors:{ 
    email:{
      message: 'validator "required" failed for path email',
      name: 'validatorerror',
      path: 'email',
      type: 'required' 
    },
    name:{ 
      message: 'validator "required" failed for path name',
      name: 'validatorerror',
      path: 'name',
      type: 'required' 
    } 
  } 
}

知道该错误信息的具体格式之后，我们可以从中得出我们想要的信息并反馈到控制台。

if(err){
  object.keys(err.errors).foreach(function(key) {
    var message = err.errors[key].message;
    console.log('validation error for "%s": %s', key, message);
  });
}

2.自定义数据验证

最简单的自定义数据验证方式就是定义一个数据验证的函数，并将它传递给schema;

var lengthvalidator = function(val) {
  if (val && val.length >= 5){
    return true;
  }
  return false;
};
//usage:
name: {type: string, required: true, validate: lengthvalidator }

可以看到，我们只需要在schema中添加validate键值对即可，validate对应的值便是我们自定义的验证方法；

但是该形式的数据验证无法给我们提供完整的错误信息，比如errors信息中返回的type值就会成为undefined;

在此基础上如果希望错误信息中能返回一个错误描述，那我们可以稍微进行一点修改：

//code 1
validate: { validator: lengthvalidator, msg: 'too short' }

//code 2
var weekdayschema = new schema({
  day : {type: string, validate: {validator:/^(mon|tues|wednes|thurs|fri)day$/i, msg: 'not a day' }
});

将validate的值修改为一个对象，并且该对象包含验证器和错误描述。

我们也可以使用另一种方式在写这些验证器，就是将验证器卸载schema外部，例如：

 var validatelength = [lengthvalidator, 'too short' ];
 var validateday = [/^(mon|tues|wednes|thurs|fri)day$/i, 'not a day' ];
 //usage:
 name: {type: string, required: true, validate: validatelength }
 day : {type: string, validate: validateday }

眼睛放大，一看再看，确实没错，在validate中我们传入的是一个数组了，而不是原来的对象了。

其实就validatelength这个东东来说，他就是一个简写来的，你也可以改成下面这样：

 var validatelength = [
   {validator: lengthvalidator, msg: 'too short'}
 ];

恩，到这里，应该能明白了，将对象改为数组之后，我们便可以传递多个验证器给我们的schema了，的确如此。

 var validateusername = [
   {validator: lengthvalidator, msg: 'too short'} ,
   {validator: /^[a-z]+$/i, msg: 'letters only'}
 ];

我们还有另外一种方法给我们的schema提供验证器：

userschema.path('name').validate(lengthvalidator, 'too short');
userschema.path('name').validate(/^[a-z]+$/i, 'letters only');

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。