Mongodb基础一：数据库创建删除、集合创建删除、数据增删改查

1. 数据库使用

./mongod –dbpath DB_PATH开启mongodb服务，然后./mongo开启客户端；
清屏： cls
查看所有数据库列表： show dbs

2. 创建数据库

使用数据库、创建数据库：

> use joyitsai
复制代码

如果真的想把这个数据库创建成功，那么必须插入一个数据。数据库中不能直接插入数据，只能往集合(collections)中插入数据。

不需要专门创建集合，只需要写点语法插入数据就会创建集合，系统发现student是一个陌生的集合名字，所以就自动创建了集合：

> db.student.insert({'name': 'xiaoming'});
复制代码

显示当前数据库中所有集合(mysql中叫表)：

> show collections;
复制代码

删除当前所在的数据库：

> db.dropDatabase();
复制代码

删除指定集合(表)：
db.COOLECTION_NAME.drop()，例如删除上面的student集合：

> db.student.drop();
复制代码

3. 插入数据：

插入数据，随着数据的插入，数据库创建成功了，集合也创建成功了：

db.集合名.insert({"name":"zhangsan"}); 
复制代码

4. 数据查找

查询userinfo集合中所有数据：

> db.userinfo.find(); /*相当于select * from userinfo;*/
复制代码

查询去重后的字段数据：

> db.userinfo.distinct('name');
复制代码

过滤掉name中的相同数据，相当于：select distict name from userinfo;

查询age = 22的记录：

db.userInfo.find({"age": 22}); 
复制代码

相当于： select * from userInfo where age = 22;

查询age > 22的记录：

 db.userInfo.find({age: {$gt: 22}}); 
复制代码

相当于：select * from userInfo where age >22;

查询age < 22的记录：

> db.userInfo.find({age: {$lt: 22}}); 
复制代码

查询age >= 25的记录：

> db.userInfo.find({age: {$gte: 25}}); 
复制代码

相当于：select * from userInfo where age >= 25;

查询age <= 25的记录：

db.userInfo.find({age: {$lte: 25}}); 
复制代码

查询name中包含 mongo的数据(模糊查询)：

 > db.userInfo.find({name: /mongo/});
复制代码

相当于select * from userInfo where name like ‘%mongo%’;

查询name中以mongo开头的数据：

> db.userInfo.find({name: /^mongo/}); 
复制代码

相当于select * from userInfo where name like ‘mongo%’;

查询指定字段(name、age)数据：

> db.userInfo.find({}, {name: 1, age: 1}); 
复制代码

相当于：select name, age from userInfo;，当然name也可以用true或false，当用ture的情况下和name:1效果一样，如果用false就是排除name，显示name以外的列信息。

查询指定字段(name、age)数据且 age > 25 ：

> db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1}); 
复制代码

相当于：select name, age from userInfo where age >25;

按照年龄排序：

升序：

 db.userInfo.find().sort({age: 1}); 
复制代码

降序：

> db.userInfo.find().sort({age: -1}); 
复制代码

查询name = zhangsan, age = 22的数据：

 > db.userInfo.find({name: 'zhangsan', age: 22}); 
复制代码

相当于：select * from userInfo where name = ‘zhangsan’ and age = ‘22’;

查询前5条数据：

 db.userInfo.find().limit(5); 
复制代码

相当于：selecttop 5 * from userInfo;

查询10条以后的数据：

db.userInfo.find().skip(10); 
复制代码

相当于：select * from userInfo where id not in ( selecttop 10 * from userInfo );

查询在5-10之间的数据：

db.userInfo.find().limit(10).skip(5); 
复制代码

可用于分页，limit是pageSize，skip是第几页*pageSize

or查询：

db.userInfo.find({$or: [{age: 22}, {age: 25}]}); 
复制代码

相当于：select * from userInfo where age = 22 or age = 25;

findOne 查询第一条数据：

 db.userInfo.findOne(); 
复制代码

相当于：selecttop 1 * from userInfo;或者db.userInfo.find().limit(1);

查询某个结果集的记录条数统计数量：

db.userInfo.find({age: {$gte: 25}}).count();
复制代码

相当于：select count(*) from userInfo where age >= 20;

4. 数据的修改：

4.1一般查找修改语法：

db.集合名.update({查询条件},{ $set{修改的数据}});其中的$ set关键字是用来设置要修改的数据。如果没有用$set，那么整条数据会被重新覆盖成新设置的数据。

查找名字叫做小明的，把年龄更改为16岁：

> db.student.update({"name":"小明"},{$set:{"age":16}});
复制代码

查找数学成绩是70，把年龄更改为33岁：

> db.student.update({"math":70},{$set:{"age":33}});
复制代码

4.2 更改所有匹配项目：

默认的.update()只能更新一条数据，如果你需要更新所有与条件匹配的数据，就得加上multi选项。例如吧所有性别为男的数据将age更新为33：

> db.student.update({"sex":"男"},{$set:{"age":33}},{multi: true});
复制代码

4.3 没有使用$set关键字，原来的数据被新数据覆盖掉：

db.student.update({"name":"小明"},{"name":"大明","age":16});
复制代码

5. 删除数据

db.collectionsNames.remove( { 查询条件 } )
复制代码

默认的，.remove()方法会将匹配到的所有数据都删除掉，如果只想删除匹配到的第一条数据，使用 justOne:true:

Mongodb基础二：索引原理与使用

1. 索引的原理？

索引是对数据库表中一列或多列的值进行排序的一种数据结构，可以让我们查询数据库变得更快。为了方便后续介绍，先科普下MongoDB里的索引机制（同样适用于其他的数据库比如mysql）。

> db.person.find()
{ "_id" : ObjectId("571b5da31b0d530a03b3ce82"), "name" : "jack", "age" : 19 }
{ "_id" : ObjectId("571b5dae1b0d530a03b3ce83"), "name" : "rose", "age" : 20 }
{ "_id" : ObjectId("571b5db81b0d530a03b3ce84"), "name" : "jack", "age" : 18 }
{ "_id" : ObjectId("571b5dc21b0d530a03b3ce85"), "name" : "tony", "age" : 21 }
{ "_id" : ObjectId("571b5dc21b0d530a03b3ce86"), "name" : "adam", "age" : 18 }
复制代码

当你往某各个集合插入多个文档后，每个文档在经过底层的存储引擎持久化后，会有一个位置信息，通过这个位置信息，就能从存储引擎里读出该文档。为方便介绍，统一用pos(position的缩写)来代表位置信息。

比如上面的例子里，person集合里包含插入了5个文档，假设其存储后位置信息如下(为方便描述，文档省去_id字段)

位置信息	文档
pos1	{“name” : “jack”, “age” : 19 }
pos2	{“name” : “rose”, “age” : 20 }
pos3	{“name” : “jack”, “age” : 18 }
pos4	{“name” : “tony”, “age” : 21}
pos5	{“name” : “adam”, “age” : 18}

假设现在有个查询 db.person.find( {age: 18} ), 查询所有年龄为18岁的人，这时需要遍历所有的文档（全表扫描），根据位置信息读出文档，对比age字段是否为18。当然如果只有4个文档，全表扫描的开销并不大，但如果集合文档数量到百万、甚至千万上亿的时候，对集合进行全表扫描开销是非常大的，一个查询耗费数十秒甚至几分钟都有可能。

如果想加速 db.person.find( {age: 18} )，就可以考虑对person表的age字段建立索引。

db.person.createIndex( {age: 1} )  // 按age字段创建升序索引
复制代码

建立索引后，MongoDB会额外存储一份按age字段升序排序的索引数据，索引结构类似如下，索引通常采用类似btree的结构持久化存储，以保证从索引里快速（O(logN)的时间复杂度）找出某个age值对应的位置信息，然后根据位置信息就能读取出对应的文档。

AGE	位置信息
18	pos3
18	pos5
19	pos1
20	pos2
21	pos4

简单的说，索引就是将文档按照某个（或某些）字段顺序组织起来，以便能根据该字段高效的查询。

众所周知，MongoDB默认会为插入的文档生成_id字段（如果应用本身没有指定该字段），_id是文档唯一的标识，为了保证能根据文档id快递查询文档，MongoDB默认会为集合创建_id字段的索引。

> db.person.getIndexes() // 查询集合的索引信息
[
    {
        "ns" : "test.person",  // 集合名
        "v" : 1,               // 索引版本
        "key" : {              // 索引的字段及排序方向
            "_id" : 1           // 根据_id字段升序索引
        },
        "name" : "_id_"        // 索引的名称
    }
]
复制代码

2. MongoDB索引的基本使用

2.1 单字段索引

创建单字段索引：

> db.user.ensureIndex({name: 1})
复制代码

上述语句针对name创建了单字段索引，其能加速对name字段的各种查询请求，是最常见的索引形式，MongoDB默认创建的id索引也是这种类型。

{name: 1}代表升序索引，也可以通过{name: -1}来指定降序索引，对于单字段索引，升序/降序效果是一样的。

查看当前集合的所有索引信息：

> db.user.getIndexes()
复制代码

删除单字段索引：

db.user.dropIndex({name: 1});
复制代码

2.2 复合索引：

数字1表示name键的索引按升序存储，-1表示age键的索引按照降序方式存储。

db.user.ensureIndex({"name":1, "age":-1})
复制代码

该索引被创建后，基于name和age的查询将会用到该索引，或者是基于name的查询也会用到该索引，但是只基于age的查询将不会用到该复合索引。因此可以说，如果想用到复合索引，必须在查询条件中包含复合索引中的前N个索引列。

如果查询条件中的键值顺序和复合索引中的创建顺序不一致的话，MongoDB可以智能的帮助我们调整该顺序，以便使复合索引可以为查询所用。如：

 db.user.find({"age": 30, "name": "stephen"})
复制代码

对于上面示例中的查询条件，MongoDB在检索之前将会动态的调整查询条件的顺序，以使该查询可以用到刚刚创建的复合索引。

对于上面创建的索引，MongoDB都会根据索引的keyname和索引方向为新创建的索引自动分配一个索引名，下面的命令可以在创建索引时为其指定索引名(userindex)，如：

db.user.ensureIndex({"name":1},{"name":"userindex"})
复制代码

2.3 唯一索引

在缺省{unique:true}的情况下创建的索引均不是唯一索引。下面将创建唯一索引，如：

 db.user.ensureIndex({"userid":1},{"unique":true})
复制代码

如果再次插入userid重复的文档时，MongoDB将报错，以提示插入重复键，如：

db.user.insert({"userid":5}) 
db.user.insert({"userid":5})
复制代码

E11000 duplicate key error index: user.user.$userid_1 dup key: { : 5.0 }

如果插入的文档中不包含userid键，那么该文档中该键的值为null，如果多次插入类似的文档，MongoDB将会报出同样的错误：

E11000 duplicate key error index: user.user.$userid_1 dup key: { : null }

3. 使用explain

explain是非常有用的工具，会帮助你获得查询方面诸多有用的信息：

explain会返回查询使用的索引情况，耗时和扫描文档数的统计信息。

3.1 explain( ‘executionStats’ )查询具体的执行时间

db.tablename.find().explain( "executionStats" )
复制代码

输出的如下数值：explain.executionStats.executionTimeMillis就是当前数据查询所用的时间

参考《MongoDB索引原理》

Mongodb基础三：mongoose实现数据增删改查

菜鸟教程

添加权限控制

mongoose 的安装以及使用

安装

npm install mongoose --save
复制代码

引入mongoose并连接数据库

const mongoose = require('mongoose');
mongoose.connect('mongodb://jzcms:jzcms@152.136.136.13:27017/jzCms',(err)=>{
  if(err){
    console.log(err)
    console.log('数据库链接失败')
  }else{
    console.log('数据库连接成功');
    console.log('服务器启动成功');
    server.listen(port);
    server.on('error', onError);
    server.on('listening', onListening);
  }
})
复制代码

如果mongodb数据库有账号密码：

/**通过mongodb://username:password@host1:port/database_name?authSource指定验证前面身份信息的数据库来源 */
mongoose.connect('mongodb://账号:密码@ip地址:27017/集合名称?authSource=admin',{ 
    useNewUrlParser: true,
});
复制代码

定义一个Schema

Schema是mongoose 里会用到的一种数据模式，可以理解为表结构的定义；每个schema 会映射到mongodb 中的一个collection，它不具备操作数据库的能力，只是对数据库集合的各个字段类型的规范定义。

<!--独立-->
const mongoose = require('mongoose');
module.exports = new mongoose.Schema({
    title: String,
    shareTitle: String,
    shareImgUrl: String,
    shareDesc: String,
    content: Array
})

<!--非独立-->
var UserSchema=mongoose.Schema({
    name: String,
    age:Number,
    status:'number'
})
复制代码

创建数据模型

定义好了Schema，接下就是生成Model。model 是由schema 生成的模型，可以对数据库的操作。
mongoose.model 里面可以传入两个参数也可以传入三个参数:
mongoose.model（参数1:模型名称（首字母大写），参数2:Schema）
mongoose.model（参数1:模型名称（首字母大写），参数2:Schema，参数3:集合名称）
如果传入2 个参数的话:User模型会默认去操作与User模型同名的复数形式的集合，如通过下面方法创建模型，那么这个模型将会操作users这个集合：

var User=mongoose.model('User', UserSchema);
复制代码

如果传入3 个参数的话:模型默认操作第三个参数定义的集合名称，如下面的代码，模型User会指定操作user这个集合：

var User=mongoose.model('User', UserSchema, 'user');
复制代码


// 模型类 用于对用户的表进行操作
const mongoose = require('mongoose');

const taobaoSchema = require('../schemas/taobao');

// 创建一个模型
module.exports = mongoose.model('taobao',taobaoSchema, 'taobao');
复制代码

增删改查

查找数据

/**模型.find({查询条件}, (err, data)=>{回调函数}) */
User.find({}, (err, docs)=>{
    if(err){
        console.log(err);
        return;
    }
    console.log(docs);
});
复制代码

增加数据

/*模型实例化*/
const news = new News({
    title:'新闻标题',
    author:'joyitsai',
    pic:'01.png',
    content:'新闻内容',
    status: 1
});
/*实例.save((err,docs)=>{回调函数}) 来将数据保存到数据库*/
news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
复制代码

修改数据

ews.updateOne(
    {'_id':'5cf5e613ba3c6298a8734973'}, //条件
    {title: '这是一则新闻111'},     //要更新的内容
    /*回调函数*/
    (err, docs)=>{
        if(err){return console.log('更新数据失败');}
        console.log(docs);
    }
)
复制代码

删除数据

News.deleteOne(
    {'_id':'5cf5e613ba3c6298a8734973'}, //查找条件
    /*回调函数*/
    (err,docs)=>{
        if(err){return console.log('删除数据失败')}
        console.log(docs);
    }

)
复制代码

保存成功查找

News.updateOne(
    {'_id':'5cf5e613ba3c6298a8734973'}, //条件
    {title: '这是一则新闻111'},     //要更新的内容
    (err, docs)=>{
        if(err){
            return console.log('更新数据失败');
        }
        /**更新数据成功，紧接着查询数据 */
        News.find({},(err, docs)=>{
            if(err){
                return console.log(err)
            }
            console.log(docs);
        })
    }
)
复制代码

MongoDB基础四：mongoose设置默认值、模块化及性能测试

1. mongoose设置默认值

1.1 Schema中未定义的字段，其数据不能被添加

在上一篇文章里说到，首先要定义一个Schema，作为对数据库集合的各个字段类型的规范定义，此外，在添加数据时，如果添加的数据字段没有在Schema中定义，那么该字段数据不会被添加到集合里：

/*定义Schema*/
const NewsSchema = mongoose.Schema({
    title: String,
    author: String,
    pic:String,
    content: String,
    status: Number
});

/*定义News模型*/
const News = mongoose.model('News', NewsSchema, 'news');

/*实例化模型，添加数据*/
const news = new News({
    title:'最新新闻',
    author:'joyitsai',
    pic:'03.png',
    content:'新闻内容',
    status: 1,
    views: 300
});

news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
复制代码

上面再添加数据时，views:200字段的数据再Schema中并没有定义，那么再添加数据时，这个字段的数据并不会被加到集合中，查看一下news集合的数据

> db.news.find()
{ "_id" : ObjectId("5cf62d5333e8ab297050eb97"), "title" : "最新新闻", "author" : "joyitsai", "pic" : 
"03.png", "content" : "新闻内容", "status" : 1, "__v" : 0 }
复制代码

1.2 Schema定义时，指定默认值：

在Schema中定义字段的默认值，添加数据时，如果该字段数据没有被添加，那么mongoose会自动使用Schema中该字段的默认值作为数据添加到集合里：

/*定义Schema*/
const NewsSchema = mongoose.Schema({
    title: String,
    author: String,
    pic:String,
    content: String,
    /*指定字段的type、默认值*/
    status: {
        type: Number,
        default: 1
    }
});

const News = mongoose.model('News', NewsSchema, 'news');

/*添加数据，不添加status字段时，会自动使用默认值添加*/
const news = new News({
    title:'最新新闻007',
    author:'joyitsai',
    pic:'07.png',
    content:'新闻内容007'
});

news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
复制代码

查看刚刚添加的数据，会发现数据中有status:1字段：

> db.news.find()
{ "_id" : ObjectId("5cf630516b0b333d40a59f31"), "status" : 1, "title" : "最新新闻007", "author" : 
"joyitsai", "pic" : "07.png", "content" : "新闻内容007", "__v" : 0 }
复制代码

2. mongoose模块化：

在每次使用mongoose来操作数据库时，都要写连接数据库、定义Schema、定义模型，显得很繁琐。那么现在就用模块化来解决这个问题。

简单说，就是把连接数据库、定义Schema、定义模型都写成独立的模块，在相应功能代码中直接引入模块，进行数据库操作即可。

2.1 连接数据库——模块化：

// db.js

const mongoose = require('mongoose');
mongoose.connect(
    'mongodb://127.0.0.0:27017/databaseName',
    {useNewUrlParser: true,},
    (err)=>{
        if(err){
            console.log('数据库连接失败');
            return;
        }
    }  
)
module.exports = mongoose;
复制代码

2.2 定义Schema，定义模块

在定义Schema和模块的代码中导入上面连接成功后的mongoose模块：

// news.js
const mongoose = require('./db');
// 定义Schema
const NewsSchema = mongoose.Schema({
    title: String,
    author: String,
    pic:String,
    content: String,
    status: {
        type: Number,
        default: 1
    }
});

// 导出News模型
const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

2.3 引入news.js模型，直接操作数据库：

//insertData.js
const News = require('./myDatabase/news');

const news = new News({
    title:'最新新闻007',
    author:'joyitsai',
    pic:'07.png',
    content:'新闻内容007'
});

news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
复制代码

以上就实现了对mongoose连接数据库、定义Schema和定义模型的基本模块化就完成了。

3. 模块化性能测试

现在有人可能会对这种模块化的性能产生疑问，因为如果要对多个集合的数据进行操作，必然要在同一个文件中导入多个模型。

然而，每次导入一个模型，上层都会导入一次数据库连接的模块，会不会导致导入多个模型时数据库重复连接，而严重影响程序执行性能

其实，mongoose在内部给我们解决了这个问题，即使在一次性导入多个模型，只由第一次导入时的模块担任数据库连接工作，下面就测试一下：

//假设又封装了一个User集合模型
console.time('news')
const News = require('./myDatabase/news');

const news = new News({
    title:'最新新闻007',
    author:'joyitsai',
    pic:'07.png',
    content:'新闻内容007'
});

news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
// 测试向news集合中添加数据的时间
console.timeEnd('news');


console.time('user')
const User = require('./myDatabase/user');

const user = new User({
    name:'zhangsan',
    age: 36,
    pic:'07.png',
});

user.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
// 测试向user集合中添加数据的时间
console.timeEnd('user');
复制代码

下面看一下测试结果：

news: 341.740ms
user: 2.666ms
{ status: 1,
  _id: 5cf67e2fc3aa2254349ed978,
  title: '最新新闻007',
  author: 'joyitsai',
  pic: '07.png',
  content: '新闻内容007',
  __v: 0 }
{ status: 1,
  _id: 5cf67e2fc3aa2254349ed979,
  name: 'zhangsan',
  age: 36,
  pic: '07.png',
  __v: 0 }
复制代码

很显然，在第一次引入News模型的用时是第二次引入User模型的150倍，这验证了在多次引入模型的情况下，并不会重复连接数据库。

MongoDB基础五：Mongoose 预定义模式修饰符、Setters与Getters自定义修饰符

一、mongoose 预定义模式修饰符

mongoose 提供的预定义模式修饰符，可以对我们增加的数据进行一些格式化。mongoose提供了lowercase、uppercase 、trim预定义模式修饰符，其中trim能够对字段数据做两端去空格的格式化：

/*定义带trim修饰符的Schema*/
const NewsSchema = mongoose.Schema({
    title: {
        type:String,
        trim: true
    },
    author: String,
    pic:String,
    content: String,
    status: {
        type: Number,
        default: 1
    }
});
const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

const News = require('./myDatabase/news');
/*添加数据时，将title字段的数据两端加一些空格*/
const news = new News({
    title:'     最新新闻007     ',
    author:'joyitsai',
    pic:'07.png',
    content:'新闻内容007'
});

news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
复制代码

添加数据成功后，查看发现数据如下：

{ "_id" : ObjectId("5cf72b415b4e487a34c85cb4"), "status" : 1, "title" : "最新新闻007", "author" : 
"joyitsai", "pic" : "07.png", "content" : "新闻内容007", "__v" : 0 }
复制代码

你会发现，刚刚添加的数据中title字段数据两端的空格被格式化去掉了，就是trim的作用。

二、Mongoose Getters 与Setters 自定义修饰符

除了mongoose 内置的修饰符以外，我们还可以通过set（建议使用）修饰符在增加数据的时候对数据进行格式化。也可以通过get（不建议使用）在实例获取数据的时候对数据进行格式化。

2.1 Setters

set(用户添加数据){ return 真正添加到数据库的数据}来自定义修饰符，在set内部对用户添加的数据进行格式化操作，最终返回格式化后的数据作为真正存入数据库的数据：

const NewsSchema = mongoose.Schema({
    title: {
        type:String,
        trim: true
    },
    author: String,
    /*
      url为空，则返回空的url；
      url前面没有`http://`或`https:// `，则在前面拼接上`http://`
      返回带有`http://`或`https://`的url，作为存入数据库的数据
    */
    redirect: {
        type: String,
        set(url){
            if(!url) return url;
            if(url.indexOf('http://')!=0 && url.indexOf('https://')!=0){
                url = 'http://' + url;
            }
            return url;
        }
    } 
});

const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

添加数据时，向redirect字段添加一个www.baidu.com，然后查看存入数据库的数据是否是www.baidu.com，如果是，说明set自定义修饰符有效了：

const News = require('./myDatabase/news');

const news = new News({
    title:'     最新新闻007     ',
    author: 'joyitsai',
    redirect: 'www.baidu.com'
});

news.save((err, docs)=>{
    if(err){
        console.log('添加数据出错');
        return;
    }
    console.log(docs);
});
复制代码

查看一下数据：

{ "_id" : ObjectId("5cf731f8d8bda03afc8367b7"), "title" : "最新新闻007", "author" : "joyitsai", 
"redirect" : "http://www.baidu.com", "__v" : 0 }
复制代码

set自定义修饰符有效了。

2.2 Getters

get将用户添加的数据格式化后，并没有存入数据库；仅仅是用户在实例化模型时，这个实例中的数据被做了格式化操作，在常规应用中意义不大。

MongoDB基础六：Mongoose 索引、内置CURD 方法、扩展静态方法和实例方法

一、Mongoose 索引

索引是对数据库表中一列或多列的值进行排序的一种结构，可以让我们查询数据库变得更快。

1.1 创建索引

mongoose 中除了以前创建索引的方式，我们也可以在定义Schema时创建索引：

const NewsSchema = mongoose.Schema({
    news_id:{
        type:Number,
        // 唯一索引
        unique: true
    },
    title: {
        type:String,
        // 普通索引
        index: true
    },
    author: String,
});

const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

上面代码中，通过在Schema的字段中定义unique: true创建唯一索引，和index: true创建一般索引。

1.2 测试索引查询数据的性能

首先看一下没有索引时(将上面代码中unique: true和index: true注释掉)查询数据的时间(news集合中有100万条数据)：

console.time('news');
News.find({title: '新闻200000'}, (err, docs)=>{
    if(err) return console.log(err);
    console.log(docs);
    console.timeEnd('news');
})
复制代码

查询用时：

[ { _id: 5cf7795fb1f4664f499f265c,
    news_id: 200000,
    title: '新闻200000',
    author: 'joyitsai' } ]
news: 469.795ms
复制代码

当依照上面创建索引之后，再对这条数据进行查询，查询用时：

[ { _id: 5cf77921b1f4664f499c673c,
    news_id: 20000,
    title: '新闻20000',
    author: 'joyitsai' } ]
news: 92.108ms
复制代码

在mongoose中使用索引查询数据的性能对于没有索引的情况下有了5倍左右的提升，但没有在mongo命令行中查询时的性能好。

二、Mongoose 内置CURD

CURD: CURD是一个数据库技术中的缩写词，一般的项目开发的各种参数的基本功能都是CURD。作用是用于处理数据的基本原子操作。

Model.deleteMany()
Model.deleteOne()
Model.find()
Model.findById()
Model.findByIdAndDelete()
Model.findByIdAndRemove()
Model.findByIdAndUpdate()
Model.findOne()
Model.findOneAndDelete()
Model.findOneAndRemove()
Model.findOneAndUpdate()
Model.replaceOne()
Model.updateMany()
Model.updateOne()
复制代码

三、扩展Mongoose CURD 方法

3.1 在Schema上自定义静态方法：

在定义的Schema上通过Schema.statics.yourFind封装自己的数据查找方法，方便后期数据查找工作。callback为数据查找完成后的回调函数，回调函数中可以进行错误处理或者数据处理等操作：

const NewsSchema = mongoose.Schema({
    news_id:{
        type:Number,
        // 唯一索引
        unique: true
    },
    title: {
        type:String,
        // 普通索引
        index: true
    },
    author: String
});

// 通过Schema来自定义模型的静态方法，自定义数据查找的方法
NewsSchema.statics.findByNewsId = function(news_id, callback){
    //this指向当前模型，调用模型上的find()方法，封装自己的静态方法
    this.find({news_id: news_id}, function(err, docs){
        //数据查找完成后，调用callback，对错误信息或者查找到的数据进行处理
        callback(err, docs);
    })
}

const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

然后在相关功能代码中，就可以通过News.findByNewsId()来查找数据了：

News.findByNewsId(20000, (err, docs)=>{
    if(err) return console.log(err);
    console.log(docs);
});
复制代码

查找结果如下:

[ { _id: 5cf77921b1f4664f499c673c,
    news_id: 20000,
    title: '新闻20000',
    author: 'joyitsai' } ]
复制代码

3.2 在Schema上自定义实例方法：

实例方法是通过Schema.methods.yourMethod来定义的，其中this指向了NewsSchema对应模型的实例：

NewsSchema.methods.print = function(){
    console.log('这是一个实例方法');
    console.log(this.news_id);
}
复制代码

调用实例方法：

// 对News模型实例化
const news = new News({
    news_id: 1,
    title: '新闻1',
    author: 'joyitsai'
})

//在实例上调用实例方法
news.print();
复制代码

调用实例方法后的结果对应了实例方法的定义：

这是一个实例方法
新闻1
复制代码

实例方法不太常用，但如果你在项目中需要对数据模型实例化之后，进行一些特殊的操作，可以通过实例化方法来执行，提高功能性操作的效率。

MongoDB基础七：Mongoose 数据校验

一、Mongoose 校验参数

在定义Schema时，可以设置数据的校验参数，这样可以对操作数据库数据时，对其做进一步的规范。主要的校验参数有：

==required== : 数据可以是任意类型，表示这个数据必须传入
==max==: 用于Number 类型数据，最大值
==min==: 用于Number 类型数据，最小值
==enum==:枚举类型(数组中的类型是String)，要求数据必须满足枚举值enum: [‘0’, ‘1’, ‘2’]
==match==:增加的数据必须符合match（正则）的规则
==maxlength==：数据必须是String类型，数据最大长度
==minlength==：数据必须是String类型，数据最小长度

1.1 required示例：

// 定义news_id是必须要传入的数据
const NewsSchema = mongoose.Schema({
    news_id:{
        type:Number,
        // 唯一索引
        unique: true,
        required: true
    },
    title: {
        type:String,
        // 普通索引
        index: true
    },
    author: String
});

const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

现在我们在news集合中添加数据时，如果没有传入news_id的字段数据，就会报错：

const news = new News({
    /*此处没有传入news_id数据*/
    title: '新闻1',
    author: 'joyitsai'
})

news.save((err, docs)=>{
    if(err) return console.log(err);
    console.log(docs);
})
复制代码

运行报错：

{ ValidationError: News validation failed: news_id: Path `news_id` is required.
  .....
}
复制代码

1.2 max和min示例：

如果Schema定义时，指定max和min，那么传入的数据值必须在min和max之间，否则报错：

const NewsSchema = mongoose.Schema({
    news_id:{
        type:Number,
        // 唯一索引
        unique: true,
    },
    title: {
        type:String,
        // 普通索引
        index: true
    },
    author: String,
    words: {
        type: Number,
        min: 200,
        max: 1000
    }
});

const News = mongoose.model('News', NewsSchema, 'news');
module.exports = News;
复制代码

现在如果添加数据时words为100：

const news = new News({
    news_id: 2,
    title: '新闻2',
    author: 'joyitsai',
    words: 100
})

news.save((err, docs)=>{
    if(err) return console.log(err);
    console.log(docs);
})
复制代码

就会提示数据不能小于min的值，相反如果数据大于max也会提示相应错误：

{ ValidationError: News validation failed: words: Path `words` (100) is less than minimum allowed value (1000).
  ......
}
复制代码

其他的几个参数就不一一举例了，请自行验证。

二、自定义校验：

类似于之前set的用法，在定义Schema时可以用validate关键字自定义一个校验器函数，来检测数据是否满足想要的规范，如果通过验证返回true，没有通过则返回false：

const NewsSchema = mongoose.Schema({
    news_id:{
        type:Number,
        // 唯一索引
        unique: true,
    },
    title: {
        type:String,
        // 普通索引
        index: true
    },
    author: String,
    content: {
        type: String,
        /*words的长度要大于8且小于20*/
        validate: function(words){
            return (words.length>=8 && words.length<=20)
        }
    }
});
复制代码

添加数据时：

const news = new News({
    news_id: 2,
    title: '新闻2',
    author: 'joyitsai',
    words: 'qwert'
})

news.save((err, docs)=>{
    if(err) return console.log(err);
    console.log(docs);
})
复制代码

提示报错：

{ ValidationError: News validation failed: words: Validator failed for path `words` with value `qwert`
  ......
}
复制代码

如果添加的words数据长度在8-20之间，就没问题了：

{ _id: 5cfd15eacf0cee3f14f5bb85,
  news_id: 2,
  title: '新闻2',
  author: 'joyitsai',
  words: 'qwertyuio',
  __v: 0 }
复制代码

MongoDB基础八：Mongodb自增id实现方法

本文实例讲述了Mongodb自增id实现方法，具体如下：

首先创建一个自动增长id集合 ids

>db.ids.save({name:"user", id:0});
复制代码

可以查看一下是否成功

> db.ids.find();
{ "_id" : ObjectId("4c637dbd900f00000000686c"), "name" : "user", "id" : 0 }
复制代码

然后每次在db.user集合里添加新用户之前，添加新用户之前自增一下 ids集合获得id：将db.ids集合中的name=”user”文档的id值加1，返回文档。

注：因为findAndModify是一个方法完成更新查找两个操作，所以具有原子性，多线程不会冲突。
然后保存相应的数据

>db.user.save({uid:userid.id, username:"dotcoo", password:"dotcoo"});
复制代码

将上面两端代码合并：

>db.user.save({
  uid: db.ids .findAndModify({
    update:{$inc:{'id':1}},
    query:{"name":"user"},
    new:true}).id, 
  username: "dotcoo",
  password:"dotcoo"});
复制代码

查询一下刚刚添加的用户数据：

> db.user.find();
{ "_id" : ObjectId("4c637f79900f00000000686d"), "uid" : 1, "username" : "admin", "password" : "admin" }
复制代码

注意：

如果你是通过mongoose模块来进行上面的操作，应使用model.findOneAndUpdate()方法对ids集合的id进行自增，另外，在新版本中，需要在mongoose.connect()时配置useFindAndModify: false,，具体原因如官方文档所提：

在js项目中使用mongoose模块实现id自增的具体代码如下：

const IDs = require('./dataModel/ids');
const Adminuser = require('./dataModel/adminuser');

IDs.findOneAndUpdate({name: 'user'}, {$inc: {id: 1}}, {new: true,}, (err, docs)=>{
    if(err) return err;
    console.log(docs);
    const adminuser = Adminuser({
        user_id: docs.id,
        username: 'admin'+docs.id,
        password: '12345678'
    });
    adminuser.save((err, docs)=>{
        if(err) return err;
        console.log(docs);
    })
})
复制代码

{new: true}选项，会将更新后的文档输出。

以守护进程方式（Linux系统），开机自启动Mongodb服务

1. 编辑mongodb的配置文件：

修改/opt/mongo/bin/mongodb.conf配置文件，在/etc/init.d中编写自启动脚本时，需要让mongodb按照配置文件来启动和关闭：

 /*数据存放目录*/
 dbpath=/opt/mongo/data/db   
 /*指定日志文件，该文件将保存所有的日志记录、诊断信息*/
 logpath=/opt/mongo/log/mongodb.log   
 /*进程ID，没有指定则启动时候就没有PID文件*/
 pidfilepath=/opt/mongo/db.pid   
//设置为true，修改数据目录存储模式，每个数据库的文件存储在DBPATH指定目录的不同的文件夹中。
//使用此选项，可以配置的MongoDB将数据存储在不同的磁盘设备上，以提高写入吞吐量或磁盘容量。
 directoryperdb=true    
//写日志的模式：设置为true为追加。默认是覆盖。如果未指定此设置，启动时MongoDB的将覆盖现有的日志文件。
 logappend=true
//绑定地址
 bind_ip= localhost
 /*端口。默认27017*/
 port=27017   
//是否后台运行，设置为true  启动进程在后台运行的守护进程模式。
 fork=true
//来禁用预分配的数据文件，会缩短启动时间，但在正常操作过程中，可能会导致性能显著下降。
 noprealloc=true
 //设置为true，使用较小的默认数据文件大小。smallfiles减少数据文件的初始大小，并限制他们到512M，也减少了日志文件的大小，
//并限制他们到128M。如果数据库很大，各持有少量的数据，会导致mongodb创建很多文件，会影响性能。
 smallfiles=true
复制代码

创建mongodb服务脚本

文件夹/etc/init.d/是用来放服务脚本的，当Linux启动时，会寻找这些目录中的服务脚本，并根据脚本的run level确定不同的启动级别。

在/etc/init.d/中创建mongodb服务脚本文件，编辑内容如下

#!/bin/bash
 #
 #chkconfig: 2345 80 90
 #description: mongodb

 start() {
  /opt/mongo/bin/mongod --config /opt/mongo/bin/mongodb.conf
 }

 stop() {
   /opt/mongo/bin/mongod --config /opt/mongo/bin/mongodb.conf --shutdown
 }
 
case "$1" in
   start)
  start
  ;;

 stop)
  stop
  ;;

 restart)
  stop
  start
  ;;
   *)
  echo 
 $"Usage: $0 {start|stop|restart}"
  exit 1
 esac
复制代码

上面脚本，是让mongodb脚本服务，可以通过service mongodb start来实现mongod服务按照配置文件启动；通过service mongodb stop来实现mongod服务按照配置文件停止；还有service mongodb restart实现mongod服务重启。

增加服务并开机启动：

chmod +x /etc/init.d/mongodb
chkconfig --add mongodb
chkconfig --level 345 mongodb on
chkconfig --list mongodb
service mongodb start
复制代码

作者：自如大前端研发中心-FE研发部架构组-冯腾飞

招聘信息

自如大前端研发中心招募新同学！
FE/IOS/Android工程师

公司福利有：

全额五险一金，并额外购买商业保险
免费健身房+年度体检
公司附近租房9折优惠
晚间打车报销
每年2次晋升机会

欢迎对技术有执着热爱的你加入我们！简历请投递 zhangxl122@ziroom.com, 或加微信 v-nice-v 详聊！

文章版权归作者所有，未经允许请勿转载。

THE END

后端

能动的电脑配件「GitHub 热点速览 v.22.11」

ES6之模拟实现一个Set类

Macallan Mail Solution IMAP 目录遍历漏洞

Array.prototype.sort是如何排序的？

Dia 文件名 远程格式化字符串漏洞

HP-UX关机缓冲区溢出漏洞

Mongodb基础