【mongo】mongoose
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 Numbervar 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); // 36var 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; } " } )游标
- limit(3) 限制返回结果的数量,
- skip(3) 跳过前3个文档,返回其余的
- sort( {“username”:1 , “age”:-1 } ) 排序 键对应文档的键名, 值代表排序方向, 1 升序, -1降序