数据库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也挺好用的,而且可以使用连缀的方法继续处理后面请求的数据

你可能感兴趣的:(mangodb,mongodb)