数据库mongoDB的使用（前后端不分离项目·中）

1.这里介绍mongoDB,mongoDB是一个非关联型的数据库，耦合性低，容易扩展，是非关联性数据库最像关联性数据库的数据库，使用键值对存储数据，不支持ACID特性，不提供sql层的解析，读写性能高，严格上说不算是一种数据库，应该是一种数据结构化存储方法的集合。
2.mangodb的下载安装挺麻烦的，安装目录路径一定要记住（我找了半天），在任意盘里创建新文件夹（data），在新文件夹中在创建新文件夹（数据库名我的叫db）。打开终端进入安装目录的bin文件，然后输入：
mongod --dbpath d:\data\db
会跳出很多代码，怎么确定是否成功，上一个终端不要关闭另开一个终端进入bin目录输入mongo 会显示版本并进入数据库操作，如果能操作就成功反之失败。
3. mongoDB的常用命令
use dbName
这行代码有就进入数据库，没有就创建然后再在进入
查看当前数据库
db

查看所有数据库（不显示空数据库）
show dbs

删库 慎用！！！！！！！！！！！
db.dropDatabase()

创建集合
db.createcollection(name,options)
name：集合名，字符
options：可选，是对象可设置的属性有：
capped 布尔 （可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。
autoIndexId 布尔 （可选）如为 true，自动在_id字段创建索引。默认为 false
size 数值 （可选）为固定集合指定一个最大值，以千字节计（KB）。如果 capped 为 true，也需要指定该字段。
max 数值 （可选）指定固定集合中包含文档的最大数量。
这里的capped和size是要结合使用的
删除集合：
db.colName.drop() //colName是你创建的集合名
查看所有集合
db.colName.find()
查看当前集合名
db.getCollectionNames()
4.数据的操作
这里信息数据设计根据需求来，最好不要出现后期增添的现象（键值对）
用户名：userName
密码：password
年龄：age
性别：sex
电话：number
1）.数据的增
插入单条：db.colName.insert({})
插入多条：db.colName.insert([{},{},{}…])
插入单条：db.colName.insertone({})
插入多条：db.colName.insertMany([{},{},{}…])
2) .数据的删
删除单条数据：db.colName.deleteOne({key:val})
删除多条数据：db.colName.deleteMany({key:val})
删除所有数据：db.colName.deleteMany({})
3）数据的改
修改单条数据：
db.colName.updateOne({key:val},{$set:{key1:newVal,key2:newVal}})

修改多条数据：
db.colName.updateMany({key:val},{$set:{key1:newVal,key2:newVal}})

Num为正自增，为负自减
自增/自减单条数据：
db.colName.updateOne({key:val},{$inc:{key1:num}})

自增/自减多条数据：
db.colName.updateMany({key:val},{$inc:{key1:num}})

4）数据的查
基本查询所有数据：
db.colName.find()

格式化查询所有数据：
db.colName.find().pretty()

指定键值对条件查询：
db.colName.find({key:val})

指定条件查询（可以为{}表示所有数据），并限制字段显示：
db.colName.find({key:val},{userName:1, pass:1})
inclusion模式，指定返回的键，不返回其他键

db.colName.find({key:val},{userName:0, pass:0})
exclusion模式，指定不返回的键，返回其他键
注意：_id默认返回，如果不需要，需主动设置_id:0

分页查询：
db.colName.find({key:val}).limit(num).skip(start)
num：表示个数
start：表示起始索引，默认为0

排序查询：
db.colName.find({key:val}).sort({key:1})
1升序，-1降序

区间查询： - 价格区间
db.colName.find({ key: {$lt:val1, $gt:val2} })
小于val1，大于val2

db.colName.find({ key: {$lte:val1, $gte:val2} })
小于等于val1，大于等于val2

模糊查询： - 搜索用了正则哦

db.colName.find({ key: /val/})
查询key中包含val的数据

db.colName.find({ key: /^val/})
查询key中包含val且以val开头的数据

或查询： - 用户名或手机号登录

db.colName.find({ $or: [{key1:val1},{key2:val2}] })
查询key1为val1或key2为val2的数据

且查询：
db.colName.find({ key1:val1, key2:val2 })
查询key1为val1且key2为val2的数据

获取指定字段的数据： - 分类
db.colName.distinct(“key”)
获取指定字段的所有数据，去重并以数组的形式返回

5.终端操作数据库的常用操作就到这下面说一下node操作数据库
1）.安装node对mongodb的支持
NodeJS中MongoDB驱动：mongooes
下载并安装mongoose
npm install mongoose -S
2) .连接并选择数据库(db.js)
引入mongoose模块
const mongoose = require(“mongoose”);
连接mongodb并选择指定数据库：dbName
mongoose.connect(“mongodb://localhost:27017/dbName”);
连接成功
mongoose.connection.on(“connected”,()=>{ })
连接断开
windows安装的mongodb用ctrl+c并不能断开连接，kill -9 不要使用不然数据库会出问题，苹果系统正常可以断开连接，windows如果实在要关，那就进入任务管理器找到mongodb的进程关掉即可，反正不影响使用。
mongoose.connection.on(“disconnected”,()=>{ })
连接错误
mongoose.connection.on(“error”,()=>{ })
连接成功之后，将该模块暴露出来：
module.exports = mongoose
3).创建集合
引入数据库的连接
const mongoose = require("./db.js")
创建集合需要使用的通用对象,里面放入字段名加字段值，根据需求设计的数据
const Schema =new mongoose.Schema（{
userId:{type:String},
userName:{type:String},
pass:{type:String},
age:{type:Number},
city:{type:String},
tel:{type:String}
}）;
创建集合后，将该模块暴露出来
module.exports = mongoose.model(“users”, userSchema);
第一个参数是设置集合名，第二个参数是之前创建的集合
4） .插入数据
引入创建集合（在创建集合中，引入了连接数据库）
const User = require("./users.js");
插入语法：
插入单条数据：User.insertMany({}, (err)=>{})
插入多条数据：User.insertMany([{},{},…], (err)=>{})
注意：数据操作，属于异步操作，需要在回调函数中查看插入结果
5) .修改数据
引入创建集合（在创建集合中，引入了连接数据库）
const User = require("./users.js");
修改语法：
修改一条：User.updateOne({key: val}, { KaTeX parse error: Expected 'EOF', got '}' at position 16: set: {kay: val}}̲, (err)=>{}) 修改…inc: {kay: val}}, (err)=>{})
修改多条：User.updateMany({key: val}, { KaTeX parse error: Expected 'EOF', got '}' at position 16: set: {kay: val}}̲, (err)=>{}) 修改…inc: {kay: val}}, (err)=>{})
6）.删除数据
引入创建集合（在创建集合中，引入了连接数据库）
const User = require("./users.js");
删除语法：
删除一条：User.deleteOne({key: val}, (err)=>{})
删除多条：User.deleteMany({key: val}, (err)=>{})
删除全部：User.deleteMany({}, (err)=>{})
7) .查询数据
引入创建集合（在创建集合中，引入了连接数据库）
const User = require("./users.js");
查询语法：

• 查找全部：
  • User.find({},{},(err, data)=>{})
    • 参数1：对象，为查询条件
    • 参数2：对象，要返回的字段
    • 参数3：函数，查询结束后执行
      • err：报错信息
      • data：查询到的数据
• 一种类似于回调函数的方法：exec
  User.find({},{}).exec((err, data)=>{})
  区间查找：
  User.find({key: {$lte:maxVal, $gte:minVal}},{}).exec((err, data)=>{})
  模糊查找：
  User.find({key: /^张/},{}).exec((err, data)=>{})
  注意：
  ^ 表示必须以指定内容开头
  如果查询的内容是变量，需要使用eval转换：eval("/"+变量名+"/")
  查找数据总数量：
  user.countDocuments().exec((err, data)=>{})
  查找指定字段的数据： - 分类
  user.distinct(“字段名”).exec((err, data)=>{})
  8）.封装数据库（sql.js）
  增删改查

module.exports = {
    AddData(collectName,data){
        return  new Promise((resolve,reject)=>{
            collectName.insertMany(data,(err)=>{
                if(!err){
                    resolve()
                }else{
                    reject(err)
                }
            })
        })
    },
    delData(collectName,where,num=1){
        let type = num ===1 ? "deleteOne" : "deleteMany";
        return  new Promise((resolve,reject)=>{
            collectName.[type](where,(err)=>{
                if(!err){
                    resolve()
                }else{
                    reject(err)
                }
            })
        })
    },
    upData(collectName,where,what,num=1){
        let type = num ===1 ? "updataOne" : "updataMany";
        return  new Promise((resolve,reject)=>{
            collectName.[type](where,what,(err)=>{
                if(!err){
                    resolve()
                }else{
                    reject(err)
                }
            })
        })
    }, 
    getData(collectName,where={}){
        return new Promise((resolve,reject)=>{
            collectName.find(where,{_id:0,_v:0}).exec((err,data)=>{
                if(!err){
                    resolve(data)
                }else{
                    reject(err)
                }
            })

        }) 
    },
    getSortData(collectName,s,where={}){
        return new Promise((resolve,reject)=>{
            collectName.find(where,{_id:0,_v:0}).sort(s).exec((err,data)=>{
                if(!err){
                    resolve(data)
                }else{
                    reject(err)
                }
            })

        }) 
    },

    getPageData(collectName,num,index,where={}){
        return new Promise((resolve,reject)=>{
            collectName.find(where,{_id:0,_v:0}).limit(num).skip(num*index).exec((err,data)=>{
                if(!err){
                    resolve(data)
                }else{
                    reject(err)
                }
            })

        }) 
    },
    getDataLen(collectName){
        return new Promise((resolve,reject)=>{
            collectName.countdocument().exec((err,data)=>{
                if(!err){
                    resolve(data)
                }else{
                    reject(err)
                }
                
            })
        })
    },
    getkind(collectName,col){
        return new Promise((resolve,reject)=>{
            collectName.distinct(col,(err,data)=>{
                if(!err){
                    resolve(data)
                }else{
                    reject(err)
                }
            })
        })
    }

}

这里使用了promise的减少参数
promise的使用条件：有回调，异步，需要处理成功失败
promise执行后会返回，可以使用它的实例方法then（）. catch（）,promise的all也挺好用的,而且可以使用连缀的方法继续处理后面请求的数据