Mongoose增查改删学习笔记

摘要：查询条件控制返回的字段控制选项回调函数。改查询条件需要修改的数据，不能修改主键控制选项回调函数，返回的是受影响的行数。执行查询，回调函数。使用链式语句时，可以在之后接执行查询，并指定回调函数。

初学Node.js接触到MongoDB数据库，阅读资料中推荐的都是Mongoose模块，可以更加方便的对数据库进行操作，便开始接触Mongoose。在学习时碰到许多基础问题，查阅了许多资料理来理解，此篇文章就是以自己的理解，记录下入门的基础知识，以及归纳下常用的函数以及格式，方便今后查阅。
初学笔记难免有许多不足与错误欢迎指出。

如果需要在本地测试，需要先安装MongoDB数据库。
在官网下载最新安装包。安装成功后，在命令行下进入MongoDBin目录

mongod --dbpath D:MongoDBdata

启动数据库。

http://localhost:27017/

在浏览器中访问这地址，访问正常则数据库启动成功。
更详细的说明可以查看《MongoDB的下载、安装与部署》

npm install mongoose

在已经安装过Node.js的电脑上，进入工作目录输入以上命令即可安装Mongoose模块。

Robomongo是一款不错的可视化工具，Windows、MacOS、Linux平台都有，界面也简洁。虽然有收费，普通操作免费版足够用。
官网下载

在需要使用的js文件中引入模块。

var mongoose = require("mongoose");

var db = mongoose.connect("mongodb://localhost/mongodb");

URL以mongodb:// + [用户名:密码@] +数据库地址[:端口] + 数据库名。（默认端口27017）
需要对连接状况进行判断，可以用以下代码：

db.connection.on("error", function (error) {  
    console.log("数据库连接失败：" + error);
});

db.connection.on("open", function () {  
    console.log("数据库连接成功"); 
})

db.connection.on("disconnected", function () {    
    console.log("数据库连接断开");  
})

最常接触到的有三个概念Schema、Model、Entity。按自己理解，
Schema是定义数据库的结构。类似创建表时的数据定义，但比创建数据库可以做更多的定义，只是没办法通过Schema对数据库进行更改。
Model是将Schema定义的结构赋予表名。但可用此名对数据库进行增删查改。
Entity是将Model与具体的数据绑定，可以对具体数据自身进行操作，例如保存数据。

Schema用来定义数据库文档结构，数据库有什么字段、字段是什么类型、默认值、主键之类的信息。除了定义结构外，还能定义文档的实例方法，静态模型方法，复合索引，中间件等。详情查看mongoose官方文档。
在引入Mongoose模块var mongoose = require("mongoose")的js文件中进行操作。

var blogSchema = new mongoose.Schema({
    title:  String,
    comments: [{ body: String, date: Date }],
    date: { type: Date, default: Date.now },
    hidden: Boolean,
    meta: {
        votes: Number,
        favs:  Number
  }
})

这样即定义了一个名为blogSchema的Schema。

如需再添加数据，用add方法。

blogSchema.add( { author: String, body: String} );

资料中介绍，Shema不仅定义了文档的结构和属性，还可以定义文档的插件、实例方法、静态方法、复合索引文档生命周期钩子，具体还需查看官方文档。

Schema.Type是Mongoose内部定义的数据类型。基本类型有：String、Number、Date、Boolean、Array、Buffer、Mixed、ObjectId。

Mixed
混合数据类型，可以直接定义{}来使用，以下两种形式等价。

new Schema({mixed: {Schema.Types.Mixed} });
new Schema({mixed: {} });

ObjectId
储存在数据库中的每个数据都会有默认的主键_id，默认存储的是ObjectId。
ObjectId是一个12字节的BSON类型字符串。按照字节顺序依次代表：
4字节：UNIX时间戳
3字节：表示运行MongoDB的机器
2字节：表示生成此_id的进程
3字节：由一个随机数开始的计数器生成的值

var blogModel = mongoose.model("Blog", blogSchema);

将名为blogSchema的Schema与Blog名字绑定，即是存入数据库的名字，但存入数据库中的名字是Blogs，会自动添加一个s。
这里将Model命名为blogModel，需要对Blog表操作的话，都需要使用变量名blogModel。

可以绑定具体数据对Model实例化。

var blogEntity = new blogModel({
    title:  "Mongoose",
    author: "L",
    body:   "Documents are instances of out model. Creating them and saving to the database is easy",
    comments: [{ body: "It"s very cool! Thanks a lot!", date: "2014.07.28" }],
    hidden: false,
    meta: {
        votes: 100,
        favs:  99
    }
})

这里将名为blogModel的Model实例化。之后我们可以用blogEntity名对数据进行保存并执行回调。

blogEntity.save(function(err, docs){
    if(err) console.log(err);
    console.log("保存成功：" + docs);
})

在平常使用SQL语句操作数据库时，取得数据后先组织成SQL语句，然后放入执行语句中执行。这里理解也是类似，取得数据先进行实例化，这一步类似于组织成SQL语句，然后再做具体操作例如上面的Save操作。但由于Node.js是异步操作，所以返回的数据利用回调函数来进行操作。

知道了以上概念后就可以对数据进行操作了，下面将列出一些常用的资料，并附上相应的例子。

所有的参数都是以JSON对象形式传入。

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

var doc = ({
    title:  "Mongoose",
    author: "L",
    body:   "Documents are instances of out model. Creating them and saving to the database is easy",
    comments: [{ body: "It"s very cool! Thanks a lot!", date: "2014.07.28" }],
    hidden: false,
    meta: {
        votes: 100,
        favs:  99
    }
};

blogModel.create(doc, function(err, docs){
    if(err) console.log(err);
    console.log("保存成功：" + docs);
});

Model#save([options], [options.safe], [options.validateBeforeSave], [fn])

var blogEntity = new blogModel({
    title:  "Mongoose",
    author: "L",
    body:   "Documents are instances of out model. Creating them and saving to the database is easy",
    comments: [{ body: "It"s very cool! Thanks a lot!", date: "2014.07.28" }],
    hidden: false,
    meta: {
        votes: 100,
        favs:  99
    }
});

blogEntity.save(function(err, docs){
    if(err) console.log(err);
    console.log("保存成功：" + docs);
});

Model.insertMany(doc(s), [options], [callback])

多条数据插入，将多条数据一次性插入，相对于循环使用create保存会更加快。

blogModel.insertMany([
    {title: "mongoose1", author: "L"}, 
    {title: "mongoose2", author: "L"}
    ], function(err, docs){
        if(err) console.log(err);
        console.log("保存成功：" + docs);
});

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

conditions：查询条件；projection：控制返回的字段；options：控制选项；callback：回调函数。

blogModel.find({title: "Mongoose", meta.votes: 100}, {title: 1, author: 1, body: 1}, function(err, docs){
    if(err) console.log(err);
    console.log("查询结果：" + docs);
})

查询“title”标题为“Mongoose”，并且“meta”中“votes”字段值为“100”的记录，返回仅返回“title”、“author”、“body”三个字段的数据。

Model.findOne([conditions], [projection], [options], [callback])

conditions：查询条件；projection：控制返回的字段；options：控制选项；callback：回调函数。
只返回第一个查询记录。

Model.findById(id, [projection], [options], [callback])

id：指定_id的值；projection：控制返回的字段；options：控制选项；callback：回调函数。

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

conditions：查询条件；doc：需要修改的数据，不能修改主键（_id）；options：控制选项；callback：回调函数，返回的是受影响的行数。
options有以下选项：
　　safe (boolean)： 默认为true。安全模式。
　　upsert (boolean)： 默认为false。如果不存在则创建新记录。
　　multi (boolean)： 默认为false。是否更新多个查询记录。
　　runValidators： 如果值为true，执行Validation验证。
　　setDefaultsOnInsert： 如果upsert选项为true，在新建时插入文档定义的默认值。
　　strict (boolean)： 以strict模式进行更新。
　　overwrite (boolean)： 默认为false。禁用update-only模式，允许覆盖记录。

blogModel.update({title: "Mongoose"}, {author: "L"}, {multi: true}, function(err, docs){
    if(err) console.log(err);
    console.log("更改成功：" + docs);
})

以上代码先查询“title”为“Mongoose”的数据，然后将它的“author”修改为“L”，“multi”为true允许更新多条查询记录。

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

一次更新多条

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

一次更新一条

Model.findByIdAndUpdate(id, [update], [options], [callback])

id：指定_id的值；update：需要修改的数据；options控制选项；callback回调函数。
options有以下选项：
　　new： bool - 默认为false。返回修改后的数据。
　　upsert： bool - 默认为false。如果不存在则创建记录。
　　runValidators： 如果值为true，执行Validation验证。
　　setDefaultsOnInsert： 如果upsert选项为true，在新建时插入文档定义的默认值。
　　sort： 如果有多个查询条件，按顺序进行查询更新。
　　select： 设置数据的返回。

Model.findOneAndUpdate([conditions], [update], [options], [callback])

conditions：查询条件；update：需要修改的数据；options控制选项；callback回调函数。
options有以下选项：
　　new： bool - 默认为false。返回修改后的数据。
　　upsert： bool - 默认为false。如果不存在则创建记录。
　　fields： {Object|String} - 选择字段。类似.select(fields).findOneAndUpdate()。
　　maxTimeMS： 查询用时上限。
　　sort： 如果有多个查询条件，按顺序进行查询更新。
　　runValidators： 如果值为true，执行Validation验证。
　　setDefaultsOnInsert： 如果upsert选项为true，在新建时插入文档定义的默认值。
　　passRawResult： 如果为真，将原始结果作为回调函数第三个参数。

Model.remove(conditions, [callback])

blogModel.remove({author: "L"}, function(err, docs){
    if(err) console.log(err);
    console.log("删除成功：" + docs);
})

删除“author”值为“L”的记录。

Model.findByIdAndRemove(id, [options], [callback])

id：指定_id的值；update：需要修改的数据；options控制选项；callback回调函数。
options有以下选项：
　　sort： 如果有多个查询条件，按顺序进行查询更新。
　　select： 设置数据的返回。

Model.findOneAndRemove(conditions, [options], [callback])

conditions：查询条件；update：需要修改的数据；options控制选项；callback回调函数。
options有以下选项：
　　sort： 如果有多个查询条件，按顺序进行查询更新。
　　maxTimeMS： 查询用时上限。
　　select： 设置数据的返回。

在之前的查询说明中仅演示了确定值的查询，如果遇到更加复杂的情况就需要使用其他一些方法。
详细的文档可以在这儿查找 mongodb查询符。

Query#exec([operation], [callback])

执行查询，回调函数。
使用find()、$where之类查询返回的是Mongoose自己封装的Query对象，使用find()可以在函数最后接上回调来获取查询到的数据。
使用链式语句时，可以在之后接.exec()执行查询，并指定回调函数。

blogModel.find({title: "Mongoose", meta.votes: 100}, {title: 1, author: 1, body: 1}).exec(function(err, docs){
    if(err) console.log(err);
    console.log("查询结果：" + docs);
})

配合各种查询符可以方便的实现复杂的查询。
比如我需要查询“title”中以“Mongoose”开头，并且“meta”中“votes”的值小余100。并且按“meta”中“votes”的值升序排序。

blogModel.and([
    { title: { $regex: "Mongoose.+","$options":"i"}},
    { meta.votes: { $lt: 100}}
).sort({ meta.votes: 1}
).exec(function(err, docs){
    if(err) console.log(err);
    console.log("查询结果：" + docs);
});

$equals 等于 ／ $gt 大于 ／ $gte 大于等于 ／ $lt 小余 ／ $lte 小余等于 ／ $ne 不等于 ／ $in 在数组中 ／ $nin 不在数组中

blogModel.find({meta.votes: {$lt: 100}});

查询“meta”中的“votes”字段值小余100的数据。

blogModel.find({title: {$in: ["Mongoose", "Mongodb", "Nodejs"]}});

查询“title”为“Mongoose”或“Mongodb”或“Nodejs”其中之一的数据。

$or 或 ／ $and 与 ／ $nor 非

blogModel.find({ $and: [
    {meta.votes: {$gte: 50}}, 
    {meta.votes: {$lt: 100}}
]});

查询“meta”中的“votes”字段值大于等于50到小余100的数据。

blogModel.find({ $nor: [
    {meta.votes: 50}, 
    {meta.votes: 100}
]});

查询“meta”中的“votes”字段值不等于50和不等于100的数据。

以上例子也可以写成这样形式，比较清晰，其他类同

blogModel.and([
    {meta.votes: {$gte: 50}}, 
    {meta.votes: {$lt: 100}}
]);
    
blogModel.nor([
    {meta.votes: 50}, 
    {meta.votes: 100}
]);

$exists　查询的字段值是否存在

blogModel.find({ title: {$exists: true}});
blogModel.where("title").exists(true)；

查询存在“title”字段的数据。

$mod　与数据进行取模运算筛选

blogModel.find({ meta.votes: {$mod: [4, 0]}});
blogModel.where("meta.votes").$mod(4, 0);

查找“meta”中的“votes”字段值与4取模后，值为0的数据。

$regex　使用正则表达式查询数据

blogModel.find({ title: { $regex: "Mongoose.+","$options":"i"}});

搜索以“Mongoose”开头的“title”字段，“options”中的“i”代表不区分大小写。
$options参数与其余用法可以查看mongodb文档中 $regex 一节。

$where　支持js表达式查询

blogModel.find({ $where: "this.comments.length === 10 || this.name.length === 5" });
blogModel.$where(function() { return this.comments.length === 10 || this.name.length === 5; });

Query#all([path], val)　　查询数组的本身及超集

blogModel.find( tags: ["nodejs", "mongoose"]);

查询“tags”的字段值同时包含有["nodejs", "mongoose"]的数据。只要值中包含此数组即返回数据，若是只包含数组中的一个则不返回此数据。

Query#elemMatch(path, criteria)　　查询数组的交集

blogModel.find( $elemMatch: { tags: "mongoose", author: "L"});

查询“tags”为“mongoose”或是“author”为“L”的数据。

Query#size([path], val)　　查询指定大小的数组

blogModel.find( tags: { $size: 2});
blogModel.where("tags").size(2);

查询“tags”数组中包含两个元素的数据。

Query#limit(val)　　限制查询返回的数量

blogModel.find( tags: "mongoose").limit(5);

查询“tags”为“mongoose”的数据，只返回前5个查询结果。

Query#skip(val)　　跳过前N个查询结果

blogModel.find( tags: "mongoose").skip(10).limit(5);

查询“tags”为“mongoose”的数据，跳过前10个查询结果，返回从第11个开始的五个查询结果。
做分页时常用到这两个，但数据量过大时就会有性能问题。

Query#sort(arg)　　对结果按某个指定字段进行排序

1、asc为升序，-1、desc为降序。可以对一个字段进行排序，也可以是多个。

blogModel.find( tags: "mongoose").skip(10).limit(5).sort("{ meta.votes: 1}");

查询“tags”为“mongoose”的数据，跳过前10个查询结果，返回从第11个开始的五个查询结果。之后按“votes”进行升序排序。

Query#count([criteria], [callback])　　计数

blogModel.count({ title: "mongoose"}, function(err, docs){});

统计“title”为“mongoose”数据的数量

Query#select(arg)　　选择指定字段

在查询中可以选择指定的查询字段，或者排除指定的字段。+为包含，-为排除。

blogModel.select("title body");

只包含“title”、“body”字段。

blogModel.select("-title -body");

排除“title”、“body”字段。