MongoDB学习记录（快速入门）

MongoDB核心

基础概念

数据库

• 数据库是按照数据结构来组织、存储和管理数据的仓库。
• 在内存中运行的，一旦程序运行结束或者计算机断电，程序运行中的数据都会丢失。
• 我们需要将一些程序运行的数据持久化到硬盘之中，以确保数据的安全性。
• 数据库就是数据持久化的最佳选择。数据库就是存储数据的仓库。

数据库分类

关系型数据库：

• MySQL、Oracle、DB2、SQL Server ······
• 关系型数据库中全是表

非关系型数据库：

• MongoDB、 Redis ······
• 键值对数据库

MongoDB

• MongoDB 是一个基于分布式文件存储的数据库.
• MongoDB 是为快速开发互联网 Web 应用而设计的数据库系统。
• MongoDB 的设计目标是极简、灵活、作为Web 应用栈的一部分。
• MongoDB 的数据模型是面向文档的，所谓文档是一种类似于 JSON 的结构，简单理解
  MongoDB 这个数据库中存的是各种各样的JSON. (BSON)

在MongoDB中有三个重要概念：

1. 数据库 (database)：
   数据库是一个数据仓库，数据库服务下可以创建多个数据库，数居库中可以存放多个集合
2. 集合 (collection)：
   集合类似于 JS 中的数组，在集合中可以存放很多文档
3. 文档 (document)
   文档是数据库中的最小单位，类似于 JS 中的对象

与JSON来对比：

• JSON文件==>数据库
• JSON中的一级数组==>集合
• 数组中的对象==>文档

MongoDB Shell

MongoDB Shell 是 MongoDB 提供的官方交互式界面，允许用户与 MongoDB 数据库进行交互、执行命令和操作数据库。

MongoDB Shell 是基于 JavaScript 的，允许用户直接在命令行或者脚本中使用 JavaScript 语言来操作 MongoDB 数据库。

安装完成后，可以来使用 MongoDB Shell 连接到 MongoDB 数据库并执行操作。

数据库命令

1.显示所有数据库

    show dbs

2. 切换到指定的数据库

    use 数据库名

注：如果数据库不存在会自动创建数据库。如果数据库内没有集合，show dbs指令不会显示该数据库

3.显示当前所在的数据库

    db

4. 删除当前数据库

    use 库名
    db.dropDatabase ()

集合命令

1. 创建集合

    db.createCollection (' 集合名称 ')

2.显示当前数据库中的所有集合

    show collections

3.删除某个集合

    db. 集合名.drop

4.重命名集合

    db.集合名.renameCollection('newName')

文档命令

1.插入文档

    db. 集合名.insert (文档对象)

2.查询文档

    db. 集合名.find (查询条件)
    
    例：
    db.test.find({name:'张三'})

注：查询后结果中，_id 是 mongodb 自动生成的唯一编号，用来唯一标识文档

3. 更新文档

    db. 集合名.update (查询条件，新的文档)
   
    例：
    db. test.update ({name: 张三 '},{$set:{age:19}})

注：如果新文档不使用$set则会覆盖旧文档

4.删除文档

    db. 集合名.remove (查询条件)

Mongoose

Mongoose简介

Mongoose （http://www.mongoosejs.net）是一个对象文档模型库

可以让我们使用代码来进行操作 mongodb 数据库

使用方法

连接数据库

首先需要安装Mongoose

    npm i mongoose

//导入mongoose
const mongoose = require('mongoose');

//连接数据库  mongodb://ip:端口/数据库名
mongoose.connect('mongodb://127.0.0.1:27017/test')

//设置回调函数
//连接成功回调
mongoose.connection.once('open', () => {
    console.log('数据库连接成功')
})

//连接失败回调
mongoose.connection.once('err', () => {
    console.log('数据库调用失败');
})

//连接关闭回调
mongoose.connection.once('close', () => {
    console.log('数据库连接关闭');
})

//开启定时器，关闭链接
setTimeout(() => {
    mongoose.disconnect()
}, 3000)

创建文档结构对象和文档模型对象

//导入mongoose
const mongoose = require('mongoose')

//链接数据库
mongoose.connect('mongodb://127.0.0.1:27017/dome')

//创建文档结构对象
//该对象用于规定文档结构
let gameSchema = new mongoose.Schema({
    name: String,
    price: Number
})

//创建文档模型对象
//该对象内封装方法，用于操作数据库
//传参(集合名，文档结构对象)
let gameModel = mongoose.model('games', gameSchema)

//设置链接成功后的回调
mongoose.connection.once('open', () => {
    console.log('数据库连接成功');
    testDocumentation() //调用封装好的方法进行增删改查
})

字段值验证

Mongoose 有一些内建验证器，可以对字段值进行验证

字段值验证在创建文档结构对象时进行

let personSchema = new mongoose.Schema({
    name: {
        type: String,
        required: true //必填项
    },
    age: {
        type: Number,
        default: 18 //默认值
    },
    sex: {
        type: String,
        enum: ['男', '女'] //枚举值，设置的值必须是数组中的
    },
    card: {
        type: Number,
        unique: true //唯一值，新建集合才有效果
    }
})

添加文档（增）

添加文档，可以使用文档模型对象中的create 方法来添加，批量添加可以使用insertMany方法

添加一条时，传入参数为符合文档结构对象的对象

async function AddDocumentation() {
    //添加文档
    //使用文档模型对象中的create方法
    try {
        let add = await gameModel.create({
            name: '艾尔登法环',
            price: 298
        })
        console.log(add);
    } catch (error) {
        console.log(error);
    }

    //关闭数据库
    mongoose.disconnect()
}

添加多条，传入数组，数组内为符合文档结构对象的对象

//增加多条
async function AddDocumentationMany() {
    try {
        let add = await gameModel.insertMany([
            {
                name: '无限机兵',
                price: 159
            },
            {
                name: '匹诺曹',
                price: 298
            }
        ])
        console.log(add);
    } catch (err) {
        console.log(err);
    }

    //关闭数据库
    mongoose.disconnect()
}

注：Mongoose 6.x 版本之后的 API 变更。从 Mongoose 6 开始，所有的异步操作 （如 Model.create()、find()、save() 等）都不再支持回调函数 ，而是强制使用 Promise 或 async/await 语法。

控制台输出：

删除文档（删）

删除使用 deleteOne 方法和deleteMany方法。

传入一个查询参数即可

deleteOne为单独删除

async function DeleteDocumentOne() {
    try {
        let Delete = await gameModel.deleteOne({
            _id: '68522ffc56b9a48fd708b8fc'
        })
        console.log(Delete);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}

deleteMany为批量删除

async function DeleteDocumentMany() {
    try {
        let Delete = await gameModel.deleteMany({
            name: '黑暗之魂1'
        })
        console.log(Delete);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}

控制台输出：

更新文档（改）

更新使用 updateOne 方法和updateMany方法。

需要传入两个参数，第一个为查询参数，第二个为更新参数

该方法是直接在旧文档进行修改，不存在新文档覆盖旧文档，故不用$set

updateOne为单独更新

async function UpdateDocumentOne() {
    try {
        let update = await gameModel.updateOne(
            { _id: '68523020764ff87f3b7cabbd' },
            { name: '魂5' }
        )
        console.log(update);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}

updateMany为批量更新

async function UpdateDocumentMany() {
    try {
        let update = await gameModel.updateMany(
            { name: '黑暗之魂3' },
            { price: 99 }
        )
        console.log(update);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}

控制台输出：

查询文档（查）

查询分为单独查询，ID查询和批量查询

分别使用 findOne ( ) , findById ( ) , find ( ) 方法

单独查询需要传入查询参数，ID查询需要传入ID，批量查询传不传参数都可以

批量查询若不传参，则为查询全部数据

单独查询：

//查询一条数据
async function FindDocumentOne() {
    try {
        let find = await gameModel.findOne({ name: '无限机兵' })
        console.log(find);
    } catch (err) {
        console.log(err);
    }
}

ID查询：

//通过ID查询
async function FindDocumentID() {
    try {
        let find = await gameModel.findById('6852817f3870d51a37a2df25')
        console.log(find);
    } catch (err) {
        console.log(err);
    }
}

批量查询：

//批量查询
async function FindDocumentMany() {
    try {
        let find = await gameModel.find({ name: '魂5' })
        console.log(find);
    } catch (err) {
        console.log(err);
    }
}

控制台输出：

条件控制

在查询文档时，我们可以设置查询的条件，来获取我们想要的数据

运算符

在mongodb中不可以使用 > < = 等运算符，需要使用相应的符号来替换

|-----|------|
| 运算符 | 代替符号 |
| > | gt | | \< | lt |
| >= | gte | | \<= | lte |
| !== | $ne |

使用语法：

{ 属性名: { 运算符: 值 } }

示例：
let find01 = await gameModel.find({ price: { $lt: 200 } })

逻辑运算

|------|-----|
| 运算符 | 逻辑 |
| or | 逻辑或 | | and | 逻辑与 |

使用语法：

{ 运算符: [
    { 属性名: 值 }, 
    { 属性名: 值 }
] }

示例：
let find02 = await gameModel.find({ $or: [{ price: 298 }, { price: 99 }] })
混合用法：
let find03 = await gameModel.find({ $or: [{ price: { $lt: 300 } }, { price: { $gt: 100 } }] })

正则匹配

条件中可以直接使用正则匹配

let find04 = await gameModel.find({ name:/魂/ })

let find04 = await gameModel.find({ name: new RegExp('魂') })

个性化读取

字段筛选

在读取完文档后，对象中的一部分数据并不一定是我们所需要的

可以通过字段筛选来获取我们想要的属性

语法：

文档模型对象 . find ( ) . select ( { 属性名 : 0 , 属性名: 1 } )

0:不要的字段 1:要的字段

//批量查询
async function FindDocumentMany() {
    try {
        let find01 = await gameModel.find()
            .select({ _id: 0, name: 1, price: 1 })
        console.log(find01);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}

数据排序

根据规定属性值排序

语法：

文档模型对象 . find ( ) . sort( { 属性名 : 0 / 1 } )

0：倒序 1：正序

//批量查询
async function FindDocumentMany() {
    try {
        let find01 = await gameModel.find()
            .select({ _id: 0, name: 1, price: 1 })
            .sort({ price: 1 })
        console.log(find01);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}

数据截取

从指定位置获取到指定数量的数据

语法：

文档模型对象 . find ( ) . skip( 数字 ) //跳过几个数据

文档模型对象 . find ( ) . limit( 数字 ) //获取几个数据

//批量查询
async function FindDocumentMany() {
    try {
        let find01 = await gameModel.find()
            .select({ _id: 0, name: 1, price: 1 })
            .sort({ price: 1 })
            .skip(2)
            .limit(3)
        console.log(find01);
    } catch (err) {
        console.log(err);
    }
    mongoose.disconnect()
}