MongoDB非关系型数据库

安装：

• 官网无需安装，直接将bin文件夹路径放入环境变量中，启动命令行输入命令即可

• 启动mongodb服务器：mongod

• 设置mongodb数据库的存储路径修改默认端口：

  mongod --dbpath 路径 --port 新的端口号

  • mongodb默认端口：27017

  • mongodb默认路径c:/data/db

    如果不创建该文件夹且不设置存储路径，则报错，没有创建配置文件时

  • 每次启动该数据库时设置默认端口与默认存储路径只对本次使用有效

• ⭐️ 连接mongodb数据库：mongo

基本配置

使用软件默认也可

官网配置文档Install MongoDB Community Edition on Windows — MongoDB Manual

将MongoDB设置为系统服务，可以自动在后台启动，不需要每次都手动启动

1. 在bin同级目录下创建data文件夹

   • 在data文件夹下创建db和log文件夹，程序运行的数据库和日志文件会存储到这里

2. 创建配置文件

   • 在软件安装bin同级目录下添加配置文件mongod.cfg

     systemLog:
         destination: file
         path: D:\mySoftware\mongodb\mongodb-win32-x86_64-windows-5.0.9\data\log\mongod.log
     storage:
         dbPath: D:\mySoftware\mongodb\mongodb-win32-x86_64-windows-5.0.9\data\db
     net:
         port: 27017
     

   • path 是配置打印日志的目录

   • dbpath 是配置数据的存储位置

   • port 是配置的端口号

3. 以管理员身份打开命令行窗口

4. 执行如下命令

   mongod --config D:\mongoDB\mongodb-win32-x86_64-windows-5.0.1\mongod.cfg --install --serviceName "MongoDB"
   

   如果配置文件执行报错，最终无法启动，那么就自己在命令行配置mongoDB，把上面需要执行的命令替换为如下命令即可(注意修改自己的路径)

   mongod --dbpath "D:\mongoDB\mongodb-win32-x86_64-windows-5.0.1\data\db" --logpath "D:\mongoDB\mongodb-win32-x86_64-windows-5.0.1\data\log\mongod.log" --install --serviceName "MongoDB"
   

5. 启动mongoDB：

   net start MongoDB
   

6. 检查

   在键盘上按 “WIN+R”，输入“services.msc”指令确定。

   打开服务后，找到MongoDB，如下图表示已经成功！

到这里你已经完成了 mongoDB 的所有配置。接下来如果你需要连接数据库。分两种情况：

使用 cmd 命令窗口连接
如果你已经配置了环境变量，直接在 cmd 窗口中输入 mongo 即可连接成功
如果没有配置环境变量，则需要在 bin 目录中打开 cmd 窗口，输入 mongo

图形化软件studio3t连接

可以不使用该软件，直接使用命令行操作，该软件操作更加方便

这里推荐一个网址studio3t软件：https://robomongo.org/

快捷键

• F5执行所有命令
• F6执行光标当前行命令
• F9执行选中命令

参考https://blog.csdn.net/m0_46217225/article/details/119109334

Studio 3T 过期重置使用时间破解 mogodb

正常免费使用30天

1.创建文件 studio3t.bat 文件，编辑，把一些代码复制进去

@echo off
ECHO 重置Studio 3T的使用日期......
REG DELETE "HKEY_CURRENT_USER\Software\JavaSoft\Prefs\3t\mongochef\enterprise" /f
RMDIR /s /q %USERPROFILE%\.3T\studio-3t\soduz3vqhnnja46uvu3szq--
RMDIR /s /q %USERPROFILE%\.3T\studio-3t\Lwm3TdTxgYJkXBgVk4s3
RMDIR /s /q %USERPROFILE%\AppData\Local\t3\dataman\mongodb\app\AppRunner
RMDIR /s /q C:\Users\Public\t3\dataman\mongodb\app\AppRunner
RMDIR /s /q %USERPROFILE%\AppData\Local\Temp\t3\dataman\mongodb\app\AppRunner
RMDIR /s /q %USERPROFILE%\AppData\Local\ftuwWNWoJl-STeZhVGHKkQ--
RMDIR /s /q %USERPROFILE%\AppData\Local\Temp\ftuwWNWoJl-STeZhVGHKkQ--
RMDIR /s /q %USERPROFILE%\.cache\ftuwWNWoJl-STeZhVGHKkQ--
ECHO 重置完成, 按任意键退出......
pause>nul
EXIT

2.把 bat 文件放入以下路径下运行

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

​ 参考Studio 3T 破解 mogodb - 链滴 (ld246.com)

三大基本概念：

• 数据库 database
• 集合(数组) collection
  • 类似与SQL中的数据表，本质上是一个数组，里面包含看多个文档对象，[{},{},{}]
• 文档对象 document
  • 类似与SQL中的记录，一个文档对象{}就是一条记录
• 一个数据库由多个集合构成，一个集合包含多个文档对象。
• MongoDB中，数据库和集合都不需要手动创建，当我们创建文档时，如果文档所在的集合或数据库不存在会自动创建数据库和集合

基本使用：

• show dbs 或show databases
  • 查看所有的数据库
• use xxx
  • 切换到指定的数据库，可切换到不存在的数据库，创建文档时自动创建
• db
  • 查看当前操作的数据库
• show collections
  • 查看当前数据库中所有的集合

数据库的CRUD（增删改查）操作:

官网操作说明MongoDB CRUD Operations — MongoDB Manual

Mongoose v6.4.1: (mongoosejs.com)

插入数据

• 插入一条数据

  • db.collectionName.insertOne( {name:‘Hu’} )

    • db表示的是当前操作的数据库

  • collectionName表示操作的集合，若没有，则会自动创建

    • 插入的文档如果没有手动提供_id属性，则会自动创建一个

• 插入多条数据

  • db.collectionName.insertMany( [ {name:‘liu5’} , {name:‘liu6’} ] )
    • 需要用数组包起来

• 万能API：db.collectionName.insert()

  • 向集合中插入一个或多个文档

  • 向集合中插入一个文档

    db.collectionName.insert({name:"Hu", age:22, gender:"男"});
    

  • 向集合中插入多个文档

    db.collectionName.insert([
    	{name:"Hu", age:22, gender:"男"},
    	{name:"He", age:22, gender:"男"},
    ]);
    

#添加两万条数据
for(var i=0;i<20000;i++){
	db.users.insert({username:'liu'+i}) #需要执行20000次数据库的添加操作
}
db.users.find().count()//20000


#优化：
var arr=[];
for(var i=0;i<20000;i++){
	arr.push({username:'liu'+i})
}
db.user.insert(arr) #只需执行1次数据库的添加操作，可以节约很多时间

• 当向集合中插入文档时，如果没有给文档指定_id属性，则数据库会自动为文档添加_id用于作为文档的唯一标识（根据时间戳及机器码生成）
• _id我们可以自己指定，如果我们指定了数据库就不会在添加了，如果自己指定_id也必须确保它的唯一性

查询数据

• db.collectionName.find() 或db.collectionName.find({})

  • 查询集合所有的文档，即所有的数据。
  • 查询到的是整个数组对象。在最外层是有一个对象包裹起来的。
  • db.collectionName.count()或db.collectionName.length() 统计文档个数

• db.collectionName.find({属性:值, 属性:值})

  • 条件查询。注意：结果返回的是一个数组，可设置多个属性，各个属性间为且关系

  • 如果所查询文档的属性为一个值，则判断其是否为指定查找值

    如果所查询文档的属性为一个列表，则判断列表中是否包含指定查找值

• db.collectionName.findOne() 返回符合条件对象数组中的第一个对象

  • 注意：

    > db.students.find({_id:222}).name  //错误
    > db.students.findOne({_id:222}).name //正确
    

• db.collectionName.find({属性:值}).count()或db.collectionName.find({属性:值}).length() 统计符合条件文档个数

• MonoDB支持直接通过内嵌文档的属性进行查询，如果要查询内嵌文档则可以通过.的形式来匹配，如果要通过内嵌文档来对文档进行查询，此时属性名必须使用引号

  db.users.find({"hobby.movies":"hero"});
  

• sort() 可以用来指定文档的排序规则

  • 查询文档时，默认情况时按照_id的值进行排序（升序）
  • 1表示升序，-1表示降序
  • limit skip sort 可以以任意的顺序进行调用，系统自动按照sort skip limit顺序进行调用

  db.emp.find({}).sort({sal:1});  # 按照sal升序排列，-1为降序
  

• 设置投影

  在查询时，可以在第二个参数的位置来设置查询结果的 投影

  将显示的字段名设置为1，不显示的字段名设置为0，_id字段默认显示

  db.emp.find({}, {ename:1, _id:0, sal:1});
  

# 1.mongodb支持直接通过内嵌文档的属性值进行查询
# 什么是内嵌文档：hobby就属于内嵌文档
{
	name:'liu',
	hobby:{
		movies:['movie1','movie2'],
		cities:['zhuhai','chengdu']
	}
}

db.users.find({hobby.movies:'movie1'}) //错误
db.users.find({"hobby.movies":'movie1'})//此时查询的属性名必须加上引号



#2.查询操作符的使用
#比较操作符
$gt 大于
$gte 大于等于
$lt 小于
$lte 小于等于
$ne 不等于
$eq 等于的另一种写法，当属性为数组时，判断属性值是否为给定值，而不是判断数组中是否存在给定值，此处与（属性名:值）不同

db.users.find({num:{$gt:200}}) #大于200
db.users.find({num:{$gt:200,$lt:300}}) #大于200小于300

$or 或者
db.users.find(
    {
        $or:[
            {num:{$gt:300}},
            {num:{$lt:200}}
        ]
    }
) #大于300或小于200


#3.分页查询
db.users.find().skip(页码-1 * 每页显示的条数).limit(每页显示的条数)

db.users.find().limit(10) #前10条数据
db.users.find().skip(50).limit(10) #跳过前50条数据，即查询的是第61-70条数据，即第6页的数据
db.users.find().limit(10).skip(50) # 作用与上面相同，MongoDB会自动调整skip和limit的位置


#4.排序
# 查询文档时，默认按照_id进行排序（升序）
db.emp.find().sort({sal:1}) #1表示升序排列，-1表示降序排列
db.emp.find().sort({sal:1,empno:-1}) #先按照sal升序排列，如果遇到相同的sal，则按empno降序排列

#注意：skip,limit,sort可以以任意的顺序调用，最终的结果都是先调sort，再调skip，最后调limit

#5.设置查询结果的投影，即只过滤出自己想要的字段
db.emp.find({},{ename:1,_id:0}) #在匹配到的文档中只显示ename字段

修改数据

1. db.collectionName.update(查询条件，新对象)

   • update()默认情况下会使用新对象来替换旧对象

   • 默认只会修改一个

     将multi参数设置为true即可修改多个

     函数原型
     

   • 如果需要修改指定的属性，而不是替换需要使用"修改操作符"来完成修改

     • $set 可以用来修改文档中的指定属性
     • $unset 可以用来删除文档中的指定属性

2. db.collectionName.updateMany()

   • 同时修改多个符合条件的文档

3. db.collectionName.updateOne()

   • 修改一个符合条件的文档

4. $push向数组中添加一个新的元素，不考虑重复

   db.users.update({username:'hu'},{$push:{"hobby.movies":'movie4'}})
   

5. $addToSet向数组中添加一个元素，数组中已有该元素时不进行插入

   db.users.update({username:'liu'},{$addToSet:{"hobby.movies":'movie4'}})
   

# 1.替换整个文档
# db.collectionName.update(condiction,newDocument)

> db.students.update({_id:'222'},{name:'kang'})


# 2.修改对应的属性，需要用到修改操作符，比如$set,$unset,$push,$addToSet
db.collectionName.update(
	# 查询条件
	{_id:222},
	{
		#修改对应的属性
		$set:{ 
			name:'kang2',
			age:21
		}
		#删除对应的属性
		$unset:{
			gender:1 //这里的1可以随便改为其他的值，无影响
		}		
	},
	# {
	# 	multi:true   //表示将符合条件的文档全部修改
	# }
)

# 3.update默认与updateOne()等效，即对于匹配到的文档只更改其中的第一个
# updateMany()可以用来更改匹配到的所有文档
db.students.updateMany(
	{name:'liu'},
	{
		$set:{
			age:21,
			gender:222
		}
	}
)


# 4.向数组中添加数据
db.users.update({username:'liu'},{$push:{"hobby.movies":'movie4'}})

#如果数据已经存在，则不会添加
db.users.update({username:'liu'},{$addToSet:{"hobby.movies":'movie4'}})


# 5.自增自减操作符$inc
{$inc:{num:100}} #让num自增100
{$inc:{num:-100}} #让num自减100
db.emp.updateMany({sal:{$lt:1000}},{$inc:{sal:400}}) #给工资低于1000的员工增加400的工资

删除数据

1. db.collectionName.remove()

   • remove({属性:值})可以根据条件删除文档，传递的条件的方式和find()一样

   • 删除符合条件的文档（默认删除多个）

     若remove第二个参数传递true则可以只删除一个

     函数原型

• db.collectionName.delete({}) 清空集合，即删除所有文档，性能差，每个文档依次删除

  db.collectionName.delete() 错误

2. db.collectionName.deleteOne()

   删除一个

3. db.collectionName.deleteMany()

   删除多个

4. db.collectionName.drop()删除整个集合，性能比db.collectionName.delete({})好，删除后show collections; 查询不到该集合

   如果该集合是数据库中最后一个集合，删除后，整个数据库也会消失

5. db.dropDatabase() 删除数据库

6. 一般数据库中的数据都不会删除，所以删除的方法很少调用

   实际应用中一般会在数据中添加一个字段，表示数据是否被删除

# 1. db.collectionName.remove() 
# remove默认会删除所有匹配的文档。相当于deleteMany()
# remove可以加第二个参数，表示只删除匹配到的第一个文档。此时相当于deleteOne()
db.students.remove({name:'liu',true})

# 2. db.collectionName.deleteOne()
# 3. db.collectionName.deleteMany()
db.students.deleteOne({name:'liu'})

# 4. 删除所有数据：db.students.remove({})----性能较差，内部是在一条一条的删除文档。
# 可直接通过db.students.drop()删除整个集合来提高效率。

# 5.删除集合
db.collection.drop()

# 6.删除数据库
db.dropDatabase()

# 7.注意：删除某一个文档的属性，应该用update。   remove以及delete系列删除的是整个文档

# 8.当删除的条件为内嵌的属性时：
db.users.remove({"hobby.movies":'movie3'})

文档之间的关系：

一对一(one to one)

• 夫妻 （一个丈夫 对应 一个妻子）

• 在MongoDB 中可以通过内嵌文档的形式体现一对一关系

  db.wifeAndHusband.insert({
  	name:"黄蓉",
  	husband:{
  		name:"郭靖"
  	}
  })
  

一对多(one to many) / 多对一(many to one)

• 父母-孩子、用户-订单、文章-评论
• 也可以通过内嵌文档来映射一对多的关系

#用户与订单：
db.users.insert([
	{_id:100,username:'liu1'},
	{_id:101,username:'liu2'}
])
db.orders.insert([
	{list:['apple','banana'],user_id:100},
	{list:['apple','banana2'],user_id:100},
	{list:['apple'],user_id:101}
])

查询liu1的所有订单：
首先获取liu1的id: 
var user_id=db.users.findOne({name:'liu1'})._id;
根据id从订单集合中查询对应的订单： 
db.orders.find({user_id:user_id})

多对多 (many to many)

#老师与学生
db.teachers.insert([
    {
        _id:100,
        name:'liu1'
    },
    {
        _id:101,
        name:'liu2'
    },
    {
    	_id:102,
    	name:'liu3'
    }
])

db.students.insert([
	{
		_id:1000,
		name:'xiao',
		tech_ids:[100,101]
	},
	{
		_id:1001,
		name:'xiao2',
		tech_ids:[102]
	}
])

mongoose:

简介：

• mongoose是nodejs中的专门用于操作mongodb数据库的js库

• Mongoose是一个对象文档模型（ODM）库，它对Node原生的MongoDB模块进行了进一步的优化封装，并提供了更多的功能

• 在大多数情况下，它被用来把结构化的模式应用到一个MongoDB集合，并提供了验证和类型转换等好处

• Mongoose的好处

  • 可以为文档创建一个模式结构（Schema）
  • 可以对模型中的对象/文档进行验证
  • 数据可以通过类型转换为对象模型
  • 可以使用中间件来应用业务逻辑挂钩
  • 比Node原生的MongoDB驱动更容易

• mongoose中的对象：

  • Schema 模式对象

    Schema对象定义约束了数据库中的文档结构

  • Model 模型对象

    Model对象作为集合中的所有文档的表示，相当于MongoDB数据库中的集合collection

  • Document 文档对象

    Document表示集合中的具体文档，相当于集合中国的 一个具体的文档

安装：

npm i -s mongoose

连接数据库：

1. 项目中引入mongoose

   const mongoose = require("mongoose");
   

2. 连接mongodb数据库

   mongoose.connect("mongodb://localhost/users", {
       useNewUrlParser: true,
       useUnifiedTopology: true,
   });
   

   • mongodb:表示使用协议
   • localhost表示数据库ip地址（:端口号）,若端口号为默认端口号（27017）则可以省略不写
   • users表示数据库名

3. 监听mongodb数据库的连接状态，绑定数据库连接成功事件

   在mongoose对象中，有一个属性connection，该对象表示的就是数据库连接，通过监视该对象的状态，可以来监听数据库的连接与断开

   // 绑定数据库连接成功事件
   mongoose.connection.once("open", function () {
       console.log("连接成功");
   });
   // 绑定数据库连接断开事件
   mongoose.connection.once("close", function () {
       console.log("数据库连接已经断开");
   });
   

4. 断开数据库连接(一般不用)

   MongoDB数据库，一般情况下，只需要连接一次，连接一次以后，除非项目停止服务器关闭，否则连接一般不会断开

   mongoose.disconnect();
   

创建模式对象和模型对象：

//将mongoose.Schema 复制给一个常量
const Schema=mongooes.Schema;

//创建Schema模式对象
const stuSchema=new Schema({
    name:String,
    age:Number,
    gender:{
        type:String,       //如果只写type:String效果与下面address一样，gender写成对象模式可以更加灵活
        default:'female'   //默认值
    },
    address:String
});

//通过Schema创建Model
//mongoose.model(modelName, schema);
//modelName 就是要映射的集合名，mongoose会自动将集合名变为复数，若程序中集合名设置为复数，则不会再变复数
const StuModel=mongoose.model("student",stuSchema); //第一个参数表示创建的集合的名称，第二个参数表示利用的模式对象

利用模型对象进行增删查改操作：

添加操作：

1. Model.create(doc(s), [callback])
   • 用来创建一个或多个文档并添加到数据库中
   • 参数
     • doc(s) 可以是一个文档对象，也可以是一个文档对象的数组
     • callback 当操作完成以后调用的回调函数

UserModel.create({ user_id: 100, name: "liu1" }, function (err) {   //回调函数
  if (!err) {
    console.log("插入成功");
  } else {
    console.log(err);
  }
});

let data = [
  { user_id: 101, name: "liu2", age: 22 },
  { user_id: 102, name: "liu3" },
];
UserModel.create(data, function (err) {
  console.log(arguments[1]); //第一个参数为err值，第二个参数表示的是所添加的文档对象,是一个数组，此处显示第二个参数
});

查询操作：

1. Model.find(conditions, [projection], [options], [callback])

   • 查询所有符合条件的文档，类型为数组

   • 参数

     • conditions:查询的条件

     • projection:投影 { name: 1, gender: 1, _id: 0 } 或 ‘name gender -_id’

     • options:查询选项 { skip: xx, limit: xx }

     • callback:回调函数，查询结果会通过回调函数返回

       回调函数必须传，如果不传回调函数，就不会查询

2. Model.findById(id, [projection], [options], [callback])

   根据文档的id属性查询文档

3. Model.findOne([conditnios], [projection], [options], [callback])

   查询符合条件的第一个文档，总会返回一个具体的文档对象

   Document对象是Model的实例

4. Model.count(conditions, [callback])

   统计文档的数量，比find(conditions, [callback])再用count统计数组长度效率高

/* 
    查询:
    model.find(conditions,[projection],[options],callback)
    conditions:查询的条件 
    projection:投影  { name: 1, gender: 1, _id: 0 } 或 'name gender -_id'
    options:查询选项  { skip: xx, limit: xx }   
 
    model.findOne(...)
    model.findById(...)

    model.countDocuments(conditions,callback) 查询文档的数量
 */

UserModel.find({}, function (err, data) {
  console.log(data);  //data返回数组
});
UserModel.find(
  { name: /liu/i },
  "name gender -_id",
  { skip: 2, limit: 1 },
  function (err, data) {
    console.log(data); //返回的是一个文档对象数组
  }
);

UserModel.findById("5f9fbfba14319e492c0f5bc4", function (err, data) {
  console.log(data);
  console.log(data instanceof UserModel); //true 返回的文档对象属于模型对象（即集合）的实例对象
});

UserModel.countDocuments({}, function (err, data) {
  console.log(data);
});

修改操作：

1. Model.update(conditions, doc,[options],[callback])
   • 用来修改一个或多个文档
   • 参数
     • conditions查询条件
     • doc 修改后的对象
     • options 配置参数
     • callback 回调函数
2. Model.updateMany(conditions, doc,[options],[callback])
3. Model.updateOne(conditions, doc,[options],[callback])
4. Model.replaceOne(conditons, doc, [options], [callback])

/* 修改：
    model.update(conditions,[doc],[options],callback)
        doc:修改后的文档对象
    model.updateMany(...)
    model.uodateOne(...)
*/
UserModel.updateOne({ name: "liu1" }, { $set: { age: 22 } }, function (
  err,
  data
) {
  if (!err) {
    console.log("修改成功");
  }
});

UserModel.find({ name: "liu1" }, function (err, data) {
  console.log(data);
});

删除操作：

1. model.remove(conditions,[callback])
2. model.deleteOne(conditions,[callback])
3. model.deleteMany(conditions,[callback])

/* 
删除：
model.remove(conditions,callback)
model.deleteOne(...)
model.deleteMany(...)
*/
UserModel.remove(
  {
    name: "liu2",
  },
  function (err, data) {
    console.log("删除成功");
  }
);
UserModel.find({}, function (err, data) {
  console.log(data);
});

Document操作

Document和集合中的文档一 一对应，Document是Model的实例

通过Model查询到结果都是Document

1. 创建一个Document

   var stu = new StuModel({
   	name:"奔波霸",
   	age:48, 
   	gender:"male",
   	address:"碧波谭"
   });
   console.log(stu);   //此处会显示创建文档对象内容，会多出_id，但并未插入到数据库中，在数据库中查询不到
   

2. document方法

   • save（[options], [functions]）

     stu.save(function(err){
     	if(!err){
     		console.log("保存成功");
     	}
     });
     

   • update(update, [options], [callback])

     修改对象

     StuModel.findOne({}, function(err, doc){
         if(!err){
             doc.update({$set:{age:28}}, function(err){
                 if(!err){
                     console.log("修改成功");
                 }
             });
         }
     });
     

     或者

     StuModel.findOne({}, function(err, doc){
         if(!err){
             doc.age = 18;
     		doc.save();
         }
     });
     

   • remove([callback])

     删除对象

     StuModel.findOne({}, function(err, doc){
         if(!err){
             doc.remove(function(err){
             	if(!err){
                     console.log("删除成功");
                 }
             });
         }
     });
     

   • equals(doc)

   • id

     获取文档id值

   • get(name, [type])

     获取文档中的指定属性值

     StuModel.findOne({}, function(err, doc){
         if(!err){
             console.log(doc.get("age"));
             //或者console.log(doc.age);
         }
     });
     

   • set(path, value, [type])

     设置文档指定属性值

     StuModel.findOne({}, function(err, doc){
         if(!err){
             doc.set("name", "黄梅大王");
             console.log(doc);
             doc.save();
             //或者doc.name="黄么大王";
         }
     });
     

   • isNew

     是否存入数据库，若存入为false，否则true

   • isInit(path)

     这个属性是否初始化

   • toJSON() 有问题

     转换为一个JSON对象

     StuModel.findOne({}, function(err, doc){
         if(!err){
             console.log(doc.toJSON());
         }
     });
     

   • toObject()

     将Document对象转换成一个普通的JS对象

     转换为普通的js对象以后，注意所有的Document对象的方法和属性都不能使用

     StuModel.findOne({}, function(err, doc){
         if(!err){
            	var obj = doc.toObject();
             console.log(obj);
             
             delete obj.address; //临时删除对象的属性，必须转换为普通对象，不然删除不成功
             console.log(obj);
         }
     });
     

模块化处理：

1. 单独创建一个数据库连接文件dbconncet.js

const mongoose = require("mongoose");
mongoose.connect("mongodb://localhost/mongoose_test", {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});
mongoose.connection.once("open", function () {
  console.log("连接成功");
});

2. 为每一个集合创建一个模型对象文件xxxModel.js

const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const userSchema = new Schema({
  name:String,
    age:Number,
    gender:{
        type:String,
        default:"female"
    },
    address:String
});
const UserModel = mongoose.model("user", userSchema);
//当使用exports.module = UserModel;时，引用处需要使用.model获取该模型
module.exports = UserModel;

3. 在最终的文件index.js中引入数据库连接文件和创建模型的文件：

const mongoose = require("./dbconncet");
const PostModel = require("./models/postModel");

PostModel.findOne({}, function (err, data) {
  if (!err) {
    console.log(data);
  }
});

参考尚硅谷MongoDB入门基础教程（一天搞定mongodb）_哔哩哔哩_bilibili

https://github.com/Vacricticy/mongodb_practice