The front end uses node to access the database mongoDB and add, delete, and modify operations (already encapsulated, can be copied directly)

beginning

• The overall code is at the bottom, the middle is the introduction stage ------- direct button

• This package uses the mongodb module, which needs npm download

• This article does not involve secondary packaging (code is cleaner)

• Do not change the code after encapsulation

• The encapsulated code tries to meet different needs .

 cnpm install mongodb -S

Introduction

• First step⬇⬇

---

• Import mongodb module

const mongodb = require("mongodb");

---

• Step 2⬇⬇
• Define a variable mongoClient
• This module provides you with an attribute MongoClient , which is a constructor

const mongoClient = mongodb.MongoClient; 
const ObjectId = mongodb.ObjectId;

---

• Step 3⬇⬇

• Define link

MongoClient  对象下面给你了一个方法 connect()     //可以通过它连接数据库

_connect() 连接数据的方法，当你的函数只是在当前环境当中使用时，建议以下划线开头

cb 回调函数 传递的函数，在异步的时候能够使用它运行函数，能返回结果

第一个参数 mongodb://127.0.0.1:27017 是mongodb专属的地址

第二个参数   未来版本可能移出一些东西，使用 useUnifiedTopology: true最新的匹配规则，应该是新的地址的解析

第三个参数 是回调函数（err,client）
	err 发生异常了
	client 数据连接完成以后数据库给你提供的一个操作数据的入口

function _connect(cb){
    mongoClient.connect("mongodb://127.0.0.1:27017",{useUnifiedTopology: true },(err,client)=>{
        if(err) console.log("连接失败")
        else{
            const db = client.db("ele");  //指定你要操作的数据库
            							  //db就是代表你的数据库
            cb(db);   //将 db 返回出去  
        }
    })
}

---

In order to understand the passed parameters more intuitively, the interface code is as follows

app.post("/login",(req,res)=>{ 
   db.findOne("adminList",  //参数1
   
   	{  //参数 2
        adminName,
        adminWord:md5(adminWord+"(*^(*&^(*&)")
    },
    
    function(err,info){  //参数3
        if(err) tools.json(res);
        else{
            ... ....
			}   //他们是一个整体，我分开的为了更好的观察
});

• Step 4⬇⬇

Operate the database

插入一条记录

     //collName:指定插入的集合
     //insertObj:插入的内容
    insertOne(collName, insertObj, cb) {
        _connect(db => {
            db.collection(collName).insertOne(insertObj, (err, results) => {    //err错误信息   results 结果
                cb(err, results);
            })
        })
    },

查找多条数据
    //collName:指定集合
    //obj:是一个对象，包含sort,limit,skip,whereObj*/
    find(collName,obj={},cb){
        // 解构赋值。
        const {skip=0,limit=0,sort={},whereObj={}} = obj;
        _connect(db=>{
            db.collection(collName).find(whereObj).limit(limit).skip(skip).sort(sort).toArray((err,results)=>{
                cb(err,results);
            })
        })
    },

查找一条数据

    findOne(collName,whereObj,cb){
        _connect(db=>{
            db.collection(collName).findOne(whereObj,cb);
        })
    },

根据ID获得详情

    findOneById(collName,id,cb){
        _connect(db=>{
            // 查找一条信息,findOne 第一个参数是条件，第二个参数是回调
            db.collection(collName).findOne({
                _id:ObjectId(id)
            },cb)
        })
    },

根据条件获得文档的数量
     //collName:指定集合的名字
     //whereObj:条件
     //cb:回调函数（返回结果）
    count(collName,whereObj,cb){
        _connect(db=>{
            db.collection(collName).countDocuments(whereObj).then(count=>{
                cb(count);
            })
        })
    },

根据ID进行删除一条操作,并返回删除以后的结果

    deleteOneById(collName,id,cb){
        _connect(db=>{
            db.collection(collName).deleteOne({
                _id:ObjectId(id),// 将字符串转为ObjectId
            },cb)
        })
    },

根据ID进行修改

    upDateOneById(collName,id,upObj,cb){
        _connect(db=>{
            // 第一个参数是条件，第二个参数是修改的内容，第三个参数是回调函数
            db.collection(collName).updateOne({
                _id:ObjectId(id)
            },upObj,cb)
        })
    }

=========================== All code ==================== ==========

const mongodb = require("mongodb");
const mongoClient = mongodb.MongoClient;//
const ObjectId = mongodb.ObjectId;
// 1、封装之后的代码尽量不要去改动
// 2、封装之后的代码尽量的满足不同的需求。
function _connect(cb){
    mongoClient.connect("mongodb://127.0.0.1:27017",{useUnifiedTopology: true },(err,client)=>{
        if(err) console.log("连接失败")
        else{
            const db = client.db("ele");
            cb(db);
        }
    })
}
module.exports = {
    /*
    * 插入一条记录。
    * collName:指定插入的集合
    * insertObj:插入的内容*/
    insertOne(collName,insertObj,cb){
        _connect(db=>{
            db.collection(collName).insertOne(insertObj,(err,results)=>{
                cb(err,results);
            })
        })
    },
    /*
    * 查找多条数据
    * collName:指定集合
    * obj:是一个对象，包含sort,limit,skip,whereObj*/
    find(collName,obj={},cb){
        // 解构赋值。
        const {skip=0,limit=0,sort={},whereObj={}} = obj;
        _connect(db=>{
            db.collection(collName).find(whereObj).limit(limit).skip(skip).sort(sort).toArray((err,results)=>{
                cb(err,results);
            })
        })
    },
    // 查找一条数据
    findOne(collName,whereObj,cb){
        _connect(db=>{
            db.collection(collName).findOne(whereObj,cb);
        })
    },
    // 根据ID获得详情。
    findOneById(collName,id,cb){
        _connect(db=>{
            // 查找一条信息,findOne 第一个参数是条件，第二个参数是回调
            db.collection(collName).findOne({
                _id:ObjectId(id)
            },cb)
        })
    },
    /**
     * 根据条件获得文档的数量
     * collName:指定集合的名字
     * whereObj:条件
     * cb:回调函数（返回结果）
     */
    count(collName,whereObj,cb){
        _connect(db=>{
            db.collection(collName).countDocuments(whereObj).then(count=>{
                cb(count);
            })
        })
    },
    // 根据ID进行删除一条操作,并返回删除以后的结果
    deleteOneById(collName,id,cb){
        _connect(db=>{
            // 语法。find insertOne,insertMany ,deleteOne
            // 第一个参数是删除的条件。第二个参数是一个回调函数，用于接收结果
            // db.collection(collName).deleteOne({
            //     _id:ObjectId(id),// 将字符串转为ObjectId
            // },function (err,results) {
            //     cb(err,results);
            // })

            db.collection(collName).deleteOne({
                _id:ObjectId(id),// 将字符串转为ObjectId
            },cb)
        })
    },
    // 根据ID进行修改。
    upDateOneById(collName,id,upObj,cb){
        _connect(db=>{
            // 第一个参数是条件，第二个参数是修改的内容，第三个参数是回调函数
            db.collection(collName).updateOne({
                _id:ObjectId(id)
            },upObj,cb)
        })
    }


}