mongoose

api:hhttp://mongoosejs.com/docs/ap...

安装及引用

安装

npm install mongoose

引用mongoose

var mongoose = require(“mongoose”);

使用mongoose链接数据库

api

mongoose.connect('mongodb://username:password@host:port/database?options...');

test

mongoose.connect('mongodb://localhost/myapp');

示例

var mongoose = require(“mongoose”); 
var db = mongoose.connect(“mongodb://127.0.0.1:27017/test”); 
db.connection.on(“error”, function (error) { 
console.log(“数据库连接失败：” + error); 
}); 
db.connection.on(“open”, function () { 
console.log(“——数据库连接成功！——”); 
});

MongoDB基础

Schema ： 一种以文件形式存储的数据库模型骨架，不具备数据库的操作能力

Model ： 由Schema发布生成的模型，具有抽象属性和行为的数据库操作对

Entity ： 由Model创建的实体，他的操作也会影响数据库

Schema

一种以文件形式存储的数据库模型骨架，无法直接通往数据库端，也就是说它不具备对数据库的操作能力.可以说是数据属性模型(传统意义的表结构)，又或着是“集合”的模型骨架

/* 定义一个 Schema */
var mongoose = require("mongoose");

var TestSchema = new mongoose.Schema({
    name : { type:String },//属性name,类型为String
    age  : { type:Number, default:0 },//属性age,类型为Number,默认为0
    time : { type:Date, default:Date.now },
    email: { type:String,default:''}
});

上面这个 TestSchema包含4个属性 [name, age, time, email]

基本属性类型有：字符串、日期型、数值型、布尔型(Boolean)、null、数组、内嵌文档等

api

Schema.prototype.clone()

var mongoose = require('mongoose');
var db = mongoose.createConnection('mongodb://127.0.0.1:27017/test'); 
var mongooseSchema = new mongoose.Schema({
  username : {type : String, default : '匿名用户'},
  title    : {type : String},
  content  : {type : String},
  time     : {type : Date, default: Date.now},
  age      : {type : Number}
});
var cloneSchema = mongooseSchema.clone();

Schema.prototype.add()

var ToySchema = new mongoose.Schema;
ToySchema.add({ name: 'string', color: 'string', price: 'number' });

Schema.prototype.path()

schema.path('name') // returns a SchemaType
schema.path('name', Number) // changes the schemaType of `name` to Number

var mongooseSchema = new mongoose.Schema({
  username : {type : String, default : '匿名用户'},
  title    : {type : String},
  content  : {type : String},
  time     : {type : Date, default: Date.now},
  age      : {type : Number}
});
console.log(mongooseSchema.path('time'));
输出：
SchemaDate {
  path: 'time',
  instance: 'Date',
  validators: [],
  setters: [],
  getters: [],
  options: { type: [Function: Date], default: [Function: now] },
  _index: null,
  defaultValue: [Function: now] }

中间件api

参考文档：https://www.cnblogs.com/surah...

Schema.prototype.pre()

有2种类型的pre hook，串行(seria)和并行(parallel)。

Serial

串行中间件是一个接一个执行，每个中间件调用next。

var schema = new Schema(..);
schema.pre('save', function(next) {
  // 做些什么
  next();
});

Parallel

并行中间件提供更细粒度的操作

var schema = new Schema(..);

// 'true'表示这是一个并行中间件. 如果你想要使用并行中间件，你必须指定true作为第二个参数 
schema.pre('save', true, function(next, done) {
  // 下一个要执行的中间件并行执行
  next();
  setTimeout(done, 100);
});

Schema.prototype.post()

Post 中间件

post中间件在hooked方法和所有它的pre中间件完成后才执行。post中间件不直接接收流控制，如没有next和done回调都传递给它。post hook能够为这些方法注册传统的事件监听器。

schema.post('init', function(doc) {
  console.log('%s has been initialized from the db', doc._id);
});
schema.post('validate', function(doc) {
  console.log('%s has been validated (but not saved yet)', doc._id);
});
schema.post('save', function(doc) {
  console.log('%s has been saved', doc._id);
});
schema.post('remove', function(doc) {
  console.log('%s has been removed', doc._id);
});

Schema.prototype.method()

追加方法

Schema.methods.say = function(){console.log(‘hello’);};
//静态方法，只限于在Model层就能使用

实例

var mongoose = require('mongoose');
var db = mongoose.createConnection('mongodb://127.0.0.1:27017/test'); 
var mongooseSchema = new mongoose.Schema({
  username : {type : String, default : '匿名用户'},
  title    : {type : String},
  content  : {type : String},
  time     : {type : Date, default: Date.now},
  age      : {type : Number}
});
// 添加 mongoose 实例方法
mongooseSchema.methods.findbyusername = function(username, callback) {
  return this.model('mongoose').find({username: username}, callback);
}
var mongooseModel = db.model('mongoose', mongooseSchema);
var mongooseEntity = new mongooseModel();
mongooseEntity.findbyusername('model_demo_username', function(error, result){
          if(error) {
              console.log(error);
          } else {
              console.log(result);
          }
          //关闭数据库链接
          db.close();
      });

公共方法

这样Model和Entity的实例就能使用这个方法了

mongooseSchema.method('meow', function () {
  console.log('meeeeeoooooooooooow');
})

var Kitty = db.model('Kitty', mongooseSchema);

var fizz = new Kitty;
fizz.meow();

schema.method({
    purr: function () {}
  , scratch: function () {}
});

// later
fizz.purr();
fizz.scratch();

Schema.prototype.static()

静态方法，只限于在Model层就能使用

var mongoose = require('mongoose');
var db = mongoose.createConnection('mongodb://127.0.0.1:27017/test'); 
var mongooseSchema = new mongoose.Schema({
  username : {type : String, default : '匿名用户'},
  title    : {type : String},
  content  : {type : String},
  time     : {type : Date, default: Date.now},
  age      : {type : Number}
});
// 添加 mongoose 静态方法，静态方法在Model层就能使用
mongooseSchema.statics.findbytitle = function(title, callback) {
  return this.model('mongoose').find({title: title}, callback);
}
var mongooseModel = db.model('mongoose', mongooseSchema);

mongooseModel.findbytitle('emtity_demo_title',function(err,res){})

model

参考文档：http://www.cnblogs.com/surahe...
由Schema构造生成的模型，除了Schema定义的数据库骨架以外，还具有数据库操作的行为，类似于管理数据库属性、行为的类

var db = mongoose.connect("mongodb://127.0.0.1:27017/test");

// 创建Model
var TestModel = db.model("test1", TestSchema);
test1 数据库中的集合名称, 不存在会创建.

创建Model

db.model(“test1”, TestSchema );

1.构造函数, 参数1:集合名称, 参数2:Schema实例

var Kitty = db.model('Kitty', mongooseSchema);

查询

model.find({}, callback);
参数1忽略,或为空对象则返回所有集合文档

mongooseSchema.statics.findbytitle = function(title, callback) {
  return this.model('mongoose').find({title: title}, callback);
}

// executing a query explicitly
var query = MyModel.find({ name: /john/i }, null, { skip: 10 })
query.exec(function (err, docs) {});

// using the promise returned from executing a query
var query = MyModel.find({ name: /john/i }, null, { skip: 10 });
var promise = query.exec();
promise.addBack(function (err, docs) {});

var ff = mongooseModel.find({ username: 'model_demo_username'},function(e,r){
        console.log('ff',r)
      });

// named john and at least 18
MyModel.find({ name: 'john', age: { $gte: 18 }});

// executes immediately, passing results to callback
MyModel.find({ name: 'john', age: { $gte: 18 }}, function (err, docs) {});

model.find({},field,callback);

过滤查询,参数2: {‘name’:1, ‘age’:0} 查询文档的返回结果包含name , 不包含age.(_id默认是1)

// name LIKE john and only selecting the "name" and "friends" fields, executing immediately
MyModel.find({ name: /john/i }, 'name friends', function (err, docs) { })

model.find({},null,{limit:20});

过滤查询,参数3: 游标操作 limit限制返回结果数量为20个,如不足20个则返回所有.

// passing options
MyModel.find({ name: /john/i }, null, { skip: 10 })

// passing options and executing immediately
MyModel.find({ name: /john/i }, null, { skip: 10 }, function (err, docs) {});

model.findOne({}, callback);

查询找到的第一个文档

// find one iphone adventures - iphone adventures??
Adventure.findOne({ type: 'iphone' }, function (err, adventure) {});

// same as above
Adventure.findOne({ type: 'iphone' }).exec(function (err, adventure) {});

// select only the adventures name
Adventure.findOne({ type: 'iphone' }, 'name', function (err, adventure) {});

// same as above
Adventure.findOne({ type: 'iphone' }, 'name').exec(function (err, adventure) {});

// specify options, in this case lean
Adventure.findOne({ type: 'iphone' }, 'name', { lean: true }, callback);

// same as above
Adventure.findOne({ type: 'iphone' }, 'name', { lean: true }).exec(callback);

// chaining findOne queries (same as above)
Adventure.findOne({ type: 'iphone' }).select('name').lean().exec(callback);

model.findById(‘obj._id’, callback);
查询找到的第一个文档,同上. 但是只接受 __id 的值查询

// find adventure by id and execute immediately
Adventure.findById(id, function (err, adventure) {});

// same as above
Adventure.findById(id).exec(callback);

// select only the adventures name and length
Adventure.findById(id, 'name length', function (err, adventure) {});

// same as above
Adventure.findById(id, 'name length').exec(callback);

// include all properties except for `length`
Adventure.findById(id, '-length').exec(function (err, adventure) {});

// passing options (in this case return the raw js objects, not mongoose documents by passing `lean`
Adventure.findById(id, 'name', { lean: true }, function (err, doc) {});

// same as above
Adventure.findById(id, 'name').lean().exec(function (err, doc) {});

创建

Model.create(文档数据, callback))
在集合中创建一个文档

// 增加记录 基于model操作
var doc = {username : 'model_demo_username', title : 'model_demo_title', content : 'model_demo_content'};
mongooseModel.create(doc, function(error){
    if(error) {
        console.log(error);
    } else {
        console.log('save ok');
    }
    // 关闭数据库链接
    db.close();
});

更新

Model.update(conditions, update, function(error)
参数1:查询条件, 参数2:更新对象,可以使用MondoDB的更新修改器

//修改记录
//mongooseModel.update(conditions, update, options, callback);
var conditions = {username : 'model_demo_username'};
var update     = {$set : {age : 27, title : 'model_demo_title_update'}};
var options    = {upsert : true};
mongooseModel.update(conditions, update, options, function(error){
   if(error) {
       console.log(error);
   } else {
       console.log('update ok!');
   }
   //关闭数据库链接
   db.close();
});

删除

Model.remove(conditions,callback);
参数1:查询条件

// 删除记录
var conditions = {username: 'emtity_demo_username'};
mongooseModel.remove(conditions, function(error){
    if(error) {
        console.log(error);
    } else {
        console.log('delete ok!');
    }

    //关闭数据库链接
    db.close();
});

Model.where()

User.find({age: {$gte: 21, $lte: 65}}, callback);
等于：
User.where('age').gte(21).lte(65).exec(callback);

Entity

1.构造函数, 其实就是model的实例

new TestModel( { name:‘xueyou’, age:21 } );

2.创建, 在集合中创建一个文档.

Entity.save(callback);

由Model创建的实体，使用save方法保存数据，Model和Entity都有能影响数据库的操作，但Model比Entity更具操作性

var TestEntity = new TestModel({
       name : "Lenka",
       age  : 36,
       email: "[email protected]"
});
console.log(TestEntity.name); // Lenka
console.log(TestEntity.age); // 36

var mongooseModel = db.model('mongoose', mongooseSchema);
var doc = {username : 'model_demo_username', title : 'emtity_demo_title', content : 'emtity_demo_content'};
var mongooseEntity = new mongooseModel(doc);
mongooseEntity.save(function(error) {
    if(error) {
        console.log(error);
    } else {
        console.log('saved OK!');
    })

修改器和更新器

更新修改器:

‘$inc’ 增减修改器,只对数字有效.下面的实例: 找到 age=22的文档,修改文档的age值自增1

Model.update({‘age’:22}, {’$inc’:{‘age’:1} }  );
执行后: age=23

‘$set’ 指定一个键的值,这个键不存在就创建它.可以是任何MondoDB支持的类型.

Model.update({‘age’:22}, {’$set’:{‘age’:‘haha’} }  );
执行后: age=‘haha’

‘$unset’ 同上取反,删除一个键

Model.update({‘age’:22}, {’$unset’:{‘age’:‘haha’} }  );
执行后: age键不存在

数组修改器:

‘$push’ 给一个键push一个数组成员,键不存在会创建

Model.update({‘age’:22}, {’$push’:{‘array’:10} }  );
执行后: 增加一个 array 键,类型为数组, 有一个成员 10

‘$addToSet’ 向数组中添加一个元素,如果存在就不添加

Model.update({‘age’:22}, {’$addToSet’:{‘array’:10} }  );
执行后: array中有10所以不会添加

‘$each’ 遍历数组, 和 $push 修改器配合可以插入多个值

Model.update({‘age’:22}, {’$push’:{‘array’:{’$each’: [1,2,3,4,5]}} } );
执行后: array : [10,1,2,3,4,5]

‘$pop’ 向数组中尾部删除一个元素

Model.update({‘age’:22}, {’$pop’:{‘array’:1} }  );
执行后: array : [10,1,2,3,4]  tips: 将1改成-1可以删除数组首部元素

‘$pull’ 向数组中删除指定元素

Model.update({‘age’:22}, {’$pull’:{‘array’:10} }  );
执行后: array : [1,2,3,4]  匹配到array中的10后将其删除

条件查询

“$lt” 小于
“$lte” 小于等于
“$gt” 大于
“$gte” 大于等于
“$ne” 不等于

Model.find({“age”:{ “$get”:18 , “$lte”:30 } } );
查询 age 大于等于18并小于等于30的文档

或查询 OR

‘$in’ 一个键对应多个值
‘$nin’ 同上取反, 一个键不对应指定值
“$or” 多个条件匹配, 可以嵌套 $in 使用
“$not” 同上取反, 查询与特定模式不匹配的文档
Model.find({“age”:{ “$in”:[20,21,22.‘haha’]} } );
查询 age等于20或21或21或’haha’的文档

Model.find({"$or" :  [ {‘age’:18} , {‘name’:‘xueyou’} ] });
查询 age等于18 或 name等于’xueyou’ 的文档

类型查询

null 能匹配自身和不存在的值, 想要匹配键的值 为null, 就要通过 “$exists” 条件判定键值已经存在
"$exists" (表示是否存在的意思)

Model.find(“age” :  { “$in” : [null] , “exists” : true  } );
查询 age值为null的文档

Model.find({name: {$exists: true}},function(error,docs){
  //查询所有存在name属性的文档
});

Model.find({telephone: {$exists: false}},function(error,docs){
  //查询所有不存在telephone属性的文档
});

正则表达式

MongoDb 使用 Prel兼容的正则表达式库来匹配正则表达式

find( {“name” : /joe/i } )    
查询name为 joe 的文档, 并忽略大小写

 find( {“name” : /joe?/i } )
查询匹配各种大小写组合

查询数组

Model.find({“array”:10} );
查询 array(数组类型)键中有10的文档, array : [1,2,3,4,5,10] 会匹配到

Model.find({“array[5]”:10} );
查询 array(数组类型)键中下标5对应的值是10, array : [1,2,3,4,5,10] 会匹配到

‘$all’ 匹配数组中多个元素

Model.find({“array”:[5,10]} );
查询 匹配array数组中 既有5又有10的文档

‘$size’ 匹配数组长度

Model.find({“array”:{"$size" : 3} } );
查询 匹配array数组长度为3 的文档

‘$slice’ 查询子集合返回

Model.find({“array”:{"$skice" : 10} } );
查询 匹配array数组的前10个元素

Model.find({“array”:{"$skice" : [5,10] } } );
查询 匹配array数组的第5个到第10个元素

where

用它可以执行任意javacript语句作为查询的一部分,如果回调函数返回 true 文档就作为结果的一部分返回

find( {"$where" : function(){
        for( var x in this ){
         //这个函数中的 this 就是文档
        }
        
        if(this.x !== null && this.y !== null){
            return this.x + this.y === 10 ? true : false;
        }else{
            return true;
        }
        
        
}  }  )

简化版本

find( {"$where" :  "this.x + this.y === 10" } )
    find( {"$where" : " function(){ return this.x + this.y ===10; } " } )

游标

1. limit(3) 限制返回结果的数量,
2. skip(3) 跳过前3个文档,返回其余的
3. sort( {“username”:1 , “age”:-1 } ) 排序 键对应文档的键名, 值代表排序方向, 1 升序, -1降序