关于javascript:前端培训中级阶段51-nodeJS操作MongoDB文档CURD操作

前端最根底的就是 HTML+CSS+Javascript。把握了这三门技术就算入门，但也仅仅是入门，当初前端开发的定义曾经远远不止这些。前端小课堂（HTML/CSS/JS），本着晋升技术水平，打牢基础知识的中心思想，咱们开课啦（每周四）。

应用命令操作 MongoDB 数据库

数据库操作

1. 显示所有数据库
   show dbs
2. 切换数据库
   use <DATABASE_NAME>。比如说咱们切换到 admin 数据库 use admin。
   如果数据库不存在，则创立数据库。如果数据库存在，则切换到指定数据库。
3. 显示以后操作的数据库
   db
4. 显示以后数据库下的所有表
   show collections
5. 删除以后数据库，这种危险命令还是不要学了
   db.dropDatabase()

数据操作

因为没有表的概念（汇合），也不要求字段统一（文档）。所以咱们间接高兴的操作数据就好了。

操作命令为 db.<collection>.<>，比方咱们查 user 表的记录 db.user.find()。

也能够应用 tab 来主动补全。

insert 插入操作

留神: 在 MongoDB 中，汇合只有在内容插入后才会创立! 就是说，创立汇合 (数据表) 后要再插入一个文档 (记录)，汇合才会真正创立。（db.createCollection(name, options) 这种创立命令不会也罢，当然如果你须要定制 options 还是须要应用的）

1. 插入一个文档，如果主键反复则报错。
   db.<collection>.insert(document)

2. 插入一个文档，如果主键反复则报错。（3.2+ 新增）
   db.<collection>.insertOne(document)

   db.collection.insertOne(
      <document>,
      {writeConcern: <document>}
   )

   参数阐明：

   • document：要写入的文档。
   • writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求。

3. 插入多个文档，如果主键反复则报错。（3.2+ 新增）
   db.<collection>.insertMany([document1,document2])

   db.collection.insertMany(
      <document>,
      {
         writeConcern: <document>, 
         ordered: <boolean>
      }
   )

   参数阐明：

   • document：要写入的文档。
   • writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求。
   • ordered：指定是否按程序写入，默认 true，按程序写入。

select 查问操作

1. 查问文档
   db.<collection>.find()

   db.collection.find(
       query, 
       projection
   )

   参数阐明：

   • query：可选，应用查问操作符指定查问条件
   • projection：可选，应用投影操作符指定返回的键。查问时返回文档中所有键值，只需省略该参数即可（默认省略）
2. 查问一个文档
   db.<collection>.findOne()

update 更新

1. 更新汇合
   db.<collection>.update()

   db.collection.update( 
       <query>, 
       <update>, 
       { 
           upsert: <boolean>, 
           multi: <boolean>, 
           writeConcern: <document> 
       } 
   )

   参数阐明：

   • query : update 的查问条件，相似与 sql 语句中的 update 查问内的 where 前面的条件。
   • update : update 的对象和一些更新的操作符（如 $,$inc…）等，也能够了解为 sql update 查问内 set 前面的
   • upsert : 可选，这个参数的意思是，如果不存在 update 的记录，是否插入 objNew,true 为插入，默认是 false，不插入。
   • multi : 可选，mongodb 默认是 false, 只更新找到的第一条记录，如果这个参数为 true, 就把按条件查出来多条记录全副更新。
   • writeConcern : 可选，抛出异样的级别。

1. 插入一个文档，如果主键反复则更新。（相似于 mysql 中的 insertAndUpdate）（3.2+ 废除）
   db.<collection>.save(document)

   db.collection.save( 
       <document>, 
       {writeConcern: <document>} 
   )

   参数阐明：

   • document : 文档数据。
   • writeConcern : 可选，抛出异样的级别。

更多实例

// 只更新第一条记录：db.col.update({ "count" : { $gt : 1} } , {$set : { "test2" : "OK"} } );

// 全副更新：db.col.update({ "count" : { $gt : 3} } , {$set : { "test2" : "OK"} },false,true );

// 只增加第一条：db.col.update({ "count" : { $gt : 4} } , {$set : { "test5" : "OK"} },true,false );

// 全副增加进去:
db.col.update({ "count" : { $gt : 5} } , {$set : { "test5" : "OK"} },true,true );

// 全副更新：db.col.update({ "count" : { $gt : 15} } , {$inc : { "count" : 1} },false,true );

// 只更新第一条记录：db.col.update({ "count" : { $gt : 10} } , {$inc : { "count" : 1} },false,false );

delete 删除操作（没啥用，还是不会的好）

1. 删除汇合（删除所有记录）
   db.<collection>.drop()

2. 删除文档
   db.<collection>.remove()

   db.collection.remove( 
        <query>, 
        { 
            justOne: <boolean>, 
            writeConcern: <document> 
        } 
    )

   参数阐明：

   • query :（可选）删除的文档的条件。
   • justOne :（可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或应用默认值 false，则删除所有匹配条件的文档。
   • writeConcern :（可选）抛出异样的级别。
3. 删除文档（一个）
   db.<collection>.deleteOne(<query>)
4. 删除文档（多个）
   db.<collection>.deleteMany(<query>)

where 条件

1. db.col.find({"author":"www.lilnong.top"}).pretty() 查问所有 author=="www.lilnong.top" 的记录
2. db.col.find({"author":/nong/}).pretty() 含糊 查问所有 author蕴含 nong 的记录
3. db.col.find({"likes":{$lt:50}}).pretty() 查问所有 likes < 50 的记录
4. db.col.find({"likes":{$lte:50}}).pretty() 查问所有 likes <= 50 的记录
5. db.col.find({"likes":{$gt:50}}).pretty() 查问所有 likes > 50 的记录
6. db.col.find({"likes":{$gte:50}}).pretty() 查问所有 likes >= 50 的记录
7. db.col.find({"likes":{$ne:50}}).pretty() 查问所有 likes != 50 的记录
8. db.col.find({"likes":{$eq:50}}).pretty() 查问所有 likes == 50 的记录
9. db.col.find({"author":"www.lilnong.top","likes":{$lt:50}}).pretty() 查问所有 author=="www.lilnong.top" && likes < 50 的记录
10. db.col.find({$or:[{"author":"www.lilnong.top"},{"likes":{$gt:50}}]}).pretty() 查问所有 author=="www.lilnong.top" or likes > 50 的记录

分页（Limit 与 Skip）

应用 limit()办法来 读取指定数量的数据 。
应用 skip() 办法来 跳过指定数量的数据。

db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

排序

应用 sort() 办法来排序，1 为升序排列，而 -1 是用于降序排列。

db.COLLECTION_NAME.find().sort({links: 1})
示意以 links 字段升序排列

应用 NodeJS 操作 MongoDB 数据库

罕用的有两个库，mongodb 和 mongoose

mongodb

The official MongoDB driver for Node.js. Provides a high-level API on top of mongodb-core that is meant for end users.

装置与引入 mongodb

npm install mongodb --save
var MongoClient = require('mongodb')

await、async 形式调用

var MongoClient = require('mongodb').MongoClient;
// console.log(MongoClient)
MongoClient.connect(
    'mongodb://localhost:27017/sf-mongodb',
    {},
    async function(err, db){if(err) return console.error(err)
        // console.log(db);
        var dbo = db.db('sf-mongodb');
        // var data = await dbo.collection('user').find().toArray();
        // console.log(data)
        
        // 查问历史数据
        // data = await find2array(dbo, 'user');
        // console.log(data)
        consoleFindResult(dbo)        

        // 清空历史数据
        await dbo.collection('user').deleteMany({})
        consoleFindResult(dbo)
        
        // 批量插入数据 CURD 之 C create
        await dbo.collection('user').insertMany([{author: 'www.lilnong.top', operManyCount: 1, operKey: 'insertMany', time: new Date()},
            {author: 'www.lilnong.top', operManyCount: 2, operKey: 'insertMany', time: new Date()}
        ])
        consoleFindResult(dbo, 'C-Many')

        // 单条插入数据 CURD 之 C create 
        await dbo.collection('user').insertOne({author: 'www.lilnong.top', operKey: 'insertOne', time: new Date()})
        consoleFindResult(dbo, 'C-One')

        // 批量更新数据 CURD 之 U update
        await dbo.collection('user').updateMany({operKey: 'insertMany'},{$set: {lastUpdateTime: new Date()}})
        consoleFindResult(dbo, 'U-Many')
        
        // 单条更新数据 CURD 之 U update
        await dbo.collection('user').updateOne({operKey: 'insertMany'},{$set: {lastUpdateTime: new Date()}})
        consoleFindResult(dbo, 'U-One')

        // 读取数据 CURD 之 R read
        console.log('R', await dbo.collection('user').find().skip(1).limit(1).toArray())
        
        // 删除数据 CURD 之 D delete
        await dbo.collection('user').deleteOne({operKey: 'insertMany'})
        consoleFindResult(dbo, 'D-One')
    }
)

async function find2array(dbo, collection){return dbo.collection(collection).find().toArray(); 
}

async function consoleFindResult(dbo, key){var data = await find2array(dbo, 'user');
        console.log(key, data.map(v=>JSON.stringify(v)))
}

回调形式调用

比拟原始的形式

var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/sf-mongodb";
 
MongoClient.connect(
    url, 
    {useNewUrlParser: true}, 
    function(err, db) {if (err) throw err;
      var dbo = db.db("sf-mongodb");
      dbo.collection('user').insertOne({author: 'www.lilnong.top', operKey: 'insertOne', time: new Date()}, 
        function(err, res) {if (err) throw err;
            console.log("文档插入胜利", res);
        }
      );
      dbo.collection('user').insertMany(
        [{author: 'www.lilnong.top', operManyCount: 1, operKey: 'insertMany', time: new Date()},
            {author: 'www.lilnong.top', operManyCount: 2, operKey: 'insertMany', time: new Date()}
        ], 
        function(err, res) {if (err) throw err;
            console.log("文档插入胜利", res);
        }
      );
      dbo.collection("user"). find({}).toArray(function(err, result) { // 返回汇合中所有数据
        if (err) throw err;
        console.log(result);
      });
      dbo.collection("user").updateOne({}, {$set: {random: Math.random()}}, function(err, res) {if (err) throw err;
        console.log("文档更新胜利");
      });
      dbo.collection("user").deleteOne({}, function(err, obj) {if (err) throw err;
        console.log("文档删除胜利");
      });
    }
);

Mongoose

Mongoose 为模型提供了一种间接的，基于 scheme 构造去定义你的数据模型。它内置数据验证，查问构建，业务逻辑钩子等，开箱即用。

我感觉就是和一些 ORM 之类的差不多。创立一个模型（model），Mongoose 会主动找到 复数 模式的 collection

反对 MongoDB 的高级（rich）查问语法。查问文档能够用 model 的 find, findById, findOne, 和 where 这些静态方法。要理解 Query api 的更多细节，能够查阅 querying 章节。

装置与引入 Mongoose

装置：npm install mongoose --save
引入：mongoose = require('mongoose')

// Mongoose 的所有始于 Schema。// 每个 schema 都会映射到一个 MongoDB collection，并定义这个 collection 里的文档的形成。var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/sf-mongodb');

var Schema = mongoose.Schema;
var userSchema = new Schema({
    author: String,
    date: {type: Date, default: Date.now}
});
var User = mongoose.model('User', userSchema);

const user = new User({author: 'lilnong.1'});
user.save().then(() => console.log('init1', 'success'));

// 间接应用对象也是能够的
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/sf-mongodb');

const User = mongoose.model('User', { author: String});

const user = new User({author: 'lilnong.2'});
user.save().then(() => console.log('init2', 'success'));

CURD

C 保留

const User = mongoose.model('User', { author: String});
const user = new User({author: 'lilnong'});
user.save().then(() => console.log('init3','success'));

U 更新

const User = mongoose.model('User', { author: String});

User.updateOne({author: 'lilnong.2'}, 
    {author: 'lilnong.3'}
).then(console.log)

R 读取

const User = mongoose.model('User', { author: String});

// 查问全量数据
User.find().then(console.log)

// 查问 author == 'lilnong.test' 的数据
User.find({author: 'lilnong.test'}).then(console.log)

D 删除

const User = mongoose.model('User', { author: String});

// 删除所有 author 为空的
User.remove({author: null}).then(console.log);

微信公众号：前端 linong

参考文献

1. 前端培训目录、前端培训布局、前端培训打算
2. mongoosejs