Nodejs-mongoose操作MongoDB

「爱情、让人受尽委屈。」 2021-12-01 14:42 274阅读 0赞

#### Nodejs 操作 MongoDB ####

*  使用官方的 `MongoDB` 包：[https://github.com/mongodb/node-mongodb-native  
    ][https_github.com_mongodb_node-mongodb-native]
 *  使用第三方的 `mongoose` 来操作 `MongoDB` 数据库
    
    `mongoose` 是基于 `MongoDB` 官方的 `mongodb` 包再一次做了封装
    
     *  mongoose 官网：[https://mongoosejs.com/  
        ][https_mongoosejs.com_]  
        安装命令
        
            npm i mongoose

#### 连接 MongoDB 数据库 ####

**[mongoose.connect(uri\[, option\]\[, callback\])][mongoose.connect_uri_ option_ callback]**：该方法用于与 MongoDB 数据库建立连接

*  `mongoose` 导入的 mongoose 模块

参数

*  `rui` 连接 MongoDB 数据库的地址
 *  `options` 该参数是一个对象，用于设置一些选项，这些选项会被传到底层 MongoDB 驱动
 *  `callback`

#### 创建集合 ####

mongoose 的一切都始于 Schema， 通过 mongoose 导出的 Schema 构造函数可以创建集合，设定集合的结构（规则）；mongoose 中的集合就相当于关系型数据库中的表结构，可以设置集合中字段的类型，默认值、约束等。

**[Schema(definition\[,options\])][Schema_definition_options]**：构造函数，通过该函数可以设计集合的结构，然后通过 new 创建实例对象；使用该构造函数时要通过 **mongoose.Schema** 获取，比如：`new mongoose.Schema()`

参数：

*  `definition` 该参数是一个对象，通过该参数定义集合中的字段并对字段设置相关约束
 *  `options`

#### 应用规则 ####

**[mongoose.model(name\[,schema\])][mongoose.model_name_schema]**：将文档结构发布为模型（应用规则）；返回值为模型构造函数。

参数

*  `name` 字符串，**首字母大写**的名词的单数形式，用来表示文档（模型）的名称； mongoose 会自动将该单词生成**小写复数**的集合名称
 *  `schema` 该参数为设计的集合结构 (规则)

#### 创建文档1 ####

所谓的创建文档就是向集合中插入数据，该过程分为两步：创建集合实例，然后调用实例对象下的 save 方法将数据保存到数据库中

###### 创建集合实例： ######

获取 model() 方法的返回的构造函数，该构造函数接收一个对象为参数，通过这个对象传入具体的数据，然后通过 new 关键字来创建实例对象

###### 保存数据： ######

**[Model.prototype.save(\[options\]\[,options.safe\]\[,options.validateBeforeSave\]\[,fn\] )][Model.prototype.save_options_options.safe_options.validateBeforeSave_fn_]**：该方法为 Model 原型上的方法，用于保存数据；有多个参数常用的为 `fn`

参数

*  `fn` 在数据保存完成后执行的回调函数，该函数有两个参数：错误对象 err，没有错误时值为 null；另一个参数为执行结果 doc（就是保存的数据）

#### 创建文档2 ####

**[Model.create(doc\[,callback\])][Model.create_doc_callback]** 将一个或多个文档保存到数据库的快捷方式；该方法的返回值为 promise 对象。

*  `Model` 调用 model() 方法后的返回值

参数

*  `doc` 需要插入集合中的文档，该参数可以是对象或数组
 *  `callback` 数据插入完成后执行的回调函数；该函数有两个参数：错误参数对象 err 和保存的数据 doc

因为该方法的返回值为 promise 对象，所以可以省略回调函数，直接使用链式编程的方式。

下面举个例子：

// 引包
    const mongoose = require('mongoose')
    
    // 连接 MongoDB 数据库，数据库不存在时会自动创建
    mongoose
      .connect('mongodb://localhost/userInfo', { 
        useNewUrlParser: true,
        useUnifiedTopology: true
      })
      .then(() => console.log('数据库连接成功'))
      .catch(err => console.log('数据库连接失败', err))
    
    // 设计集合结构（类似于表结构）
    const userSchema = new mongoose.Schema({ 
      username: { 
        type: String, // 设置字段类型
        required: true // 约束不能为空
      },
      age: Number,
      gender: Boolean,
      hobby: Array
    })
    
    // 应用集合
    let User = mongoose.model('User', userSchema)
    
    /* 创建文档1 */
    // 拿到模型构造函数，开始为所欲为（插入数据）
    let admin = new User({ 
      username: 'admin',
      age: 19,
      gender: false,
      hobby: ['book', 'music', 'shopping']
    })
    
    // 数据持久化（保存数据）
    admin.save((err, res) => { 
      if (err) console.log('保存失败！', err)
      else console.log('保存成功！', res)
    })
    
    /* 创建文档2 */
    // 通过该方法不需要去实例化集合
    User.create(
      { 
        username: 'VIP',
        age: 18,
        gender: true,
        hobby: ['running', 'basketball', 'anime']
      },
      (err, doc) => { 
        if (err) console.log('保存失败！', err)
        else console.log('保存成功', doc)
      }
    )
    
    /* 创建文档2 可写成如下形式*/
    // User.create({ 
    // username: 'VIP',
    // age: 18,
    // gender: true,
    // hobby: ['running', 'basketball', 'anime']
    // })
    // .then(doc => console.log('保存成功', doc))
    // .catch(err => console.log('保存失败！', err))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ4NjUzOQ_size_16_color_FFFFFF_t_70]

#### 查询数据 ####

**[Model.find(conditions\[,callback\])][Model.find_conditions_callback]**：用于查询集合中的文档（数据）  
参数

*  `conditions` 查询条件，其值为一个对象，条件为多个时用逗号隔开；如果省略不写将获取集合中的所有文档
 *  `callback` 查询完成后执行的回调函数，有两个参数
    
     *  `err` 错误信息，成功时值为 null
     *  `docs` 一个包含文档的数组，未查询到时为一个空数组

**[Model.findOne(conditions\[,callback\])][Model.findOne_conditions_callback]**：用于查询集合中符合条件的第一条文档（数据）；参数同上，不同的是 callback 的 doc 为查询到的一条文档，未查询到时值为 null。

举个栗子：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ4NjUzOQ_size_16_color_FFFFFF_t_70 1]

#### 常见查询条件 ####

**$lt**：小于；**$gt**：大于

// 获取 User 集合中 age 大于 16 小于 23 的文档
    User.find({  age: { $gt: 16, $lt: 23} }).then(docs => console.log(docs))

**$in**：包含

// 获取 User 集合中 hobby 包含 'music' 的文档
    User.find({  hobby: { $in: ['music']} }).then(docs => console.log(docs))

**[select(arg )][select_arg]**：指定查询到的文档包含或排除哪些字段进行显示；需要注意的是包含和排除不能同时使用。

// 排除 username 和 age 字段，不进行显示
    User.find()
      .select('-username -age')
      .then(docs => console.log(docs))

*  `arg` 该参数可以是一个字符串或对象；为字符串时多个字段之间用空格隔开，通过在字段前加 `-` 前缀可以进行排除

**[sort(arg)][sort_arg]**：对查询到的文档进行排序

*  `arg` 一个字段，默认升序排列，降序排列时在字段前加一个 `-` 前缀即可

// 按照 age 升序排列
    User.find()
      .sort('age')
      .then(docs => console.log(docs))

**[skip(val)][skip_val]**：跳过指定条数的文档

*  `val` 数量

// 跳过 2 条数据
    User.find()
      .skip(2)
      .then(docs => console.log(docs))

**[limit(val)][limit_val]**：限制显示文档的最大条数

// 显示 10 条数据
    User.find()
      .limit(10)
      .then(docs => console.log(docs))

#### 删除数据 ####

**[findOneAndDelete(\[conditions\]\[,callback\])][findOneAndDelete_conditions_callback]**：删除第一条匹配的文档；[findOneAndRemove()][findOneAndRemove] 的功能与此方法相同

参数：

*  `conditions` 该参数是一个对象用于指定查询条件
 *  `callback` 删除完成后执行的回调函数；有两个参数，错误信息 err 和 被删除的文档 doc

// 删除第一条 username 为 'VIP' 的文档
    User.findOneAndDelete({  username: 'VIP' }, (err, doc) => { 
      if (err) console.log(err)
      else console.log(doc)
    })

**[deleteMany(\[filter\]\[,callback\])][deleteMany_filter_callback]**：删除符合条件的文档（多条）；参数同上，不同的是回调函数的第二个参数为删除结果。

// 删除所有匹配的文档
    User.deleteMany({  username: 'VIP' }, (err, docs) => { 
      if (err) console.log(err)
      else console.log(docs)
    })

![在这里插入图片描述][20191220152450910.png]

#### 更新数据 ####

**[updateOne(\[criteria\]\[,doc\]\[,callback\])][updateOne_criteria_doc_callback]**：更新匹配到的第一条文档；[fandOneAndUpdate()][fandOneAndUpdate] 的功能与此方法相同

参数：

*  `criteria` 查询条件
 *  `doc` 需要更新的文档字段
 *  `callback` 更新完成后执行的回调函数；有两个参数：
    
     *  `err` 错误信息
     *  `writeOpResult` 执行成功后的结果

// 更新匹配到的第一条文档的数据
    User.updateOne({  username: 'www' }, {  age: 666 }, (err, res) => { 
      if (err) console.log(err)
      else console.log(res)
    })

![在这里插入图片描述][20191220155722509.png]  
**[updateMany()][updateMany]**：更新匹配到的所有文档；参数同上。

// 更新匹配的所有文档
    User.updateMany({  username: 'www' }, {  age: 123 }, (err, res) => { 
      if (err) console.log(err)
      else console.log(res)
    })

![在这里插入图片描述][20191220160620768.png]

#### mongoose 验证 ####

`required` 设置是否为必传字段，其值为布尔值 true 表示必传；当值为数组时可追加错误时的提示信息

required: [ true, '该字段为必填字段']

`unique` 设置字段具有唯一性；其值为布尔值 true 表示不可重复

unique: true

`minlength` 设置当前字段的最小长度

minlength: [6, '该字段最小长度为 6']

`maxlength` 设置当前字段的最大长度

`min` 设置最小数值

`max` 设置最大数值

`enum` 枚举，设置当前字段可拥有的值值为数组

gender: { 
        type: String,
        enum: ['男', '女', '妖精', '保密']
      }

`trim` 是否祛除字符串首尾的空格，为 true 时表示祛除

`validate` 自定义验证器；其值为一个对象，该对象的 validator 属性的属性值为一个函数，通过该函数可以自定义对字段的验证（函数的返回值为布尔值，为 true 时表示验证成功，否则验证失败）

intro: { 
      type: String,
      // 自定义验证
      validate: { 
        // val 为要验证的值
        validator: val => { 
          return val && val >= 5
        },
        // 自定义验证信息
        message: '最少5个字符'
      }
    }

`default` 设置默认值

举个例子：

// 引包
    const mongoose = require('mongoose')
    
    // 连接 MongoDB 数据库，数据库不存在时会自动创建
    mongoose
      .connect('mongodb://localhost/userInfo', { 
        useNewUrlParser: true,
        useUnifiedTopology: true
      })
      .then(() => console.log('数据库连接成功'))
      .catch(err => console.log('数据库连接失败', err))
    
    // 设计集合结构（类似于表结构）
    const userSchema = new mongoose.Schema({ 
      username: { 
        // 设置字段类型
        type: String,
        // 约束不能为空
        required: [true, '用户名不能为空'],
        // 最小长度
        minlength: [6, '用户名最小长度为 6'],
        // 最大长度
        maxlenght: [12, '用户名最大长度为 12'],
        // 祛除首尾空格
        trim: true
      },
      age: { 
        // 类型为 数字
        type: Number,
        // 最小值
        min: 16,
        // 最大值
        max: 23
      },
      regDate: { 
        // 日期类型
        type: Date,
        // 默认值；Date.now 当前时间
        default: Date.now
      },
      gender: { 
        type: String,
        // 枚举
        enum: ['男', '女', '妖精', '保密']
      },
      intro: { 
        type: String,
        // 自定义验证
        validate: { 
          // val 为要验证的值
          validator: val => { 
            return val && val.length >= 5
          },
          // 自定义验证信息
          message: '最少5个字符'
        }
      }
    })
    
    // 应用集合
    let User = mongoose.model('userInfo', userSchema)
    
    User.create(
      { 
        username: 'VIP',
        age: 20,
        gender: '',
        intro: '超级VIP会员！'
      },
      (err, doc) => { 
        if (err) { 
          // 获取错误对象
          let error = err.errors
          // 打印 message 信息
          for (let attr in error) { 
            console.log(error[attr].message)
          }
        } else console.log('保存成功', doc)
      }
    )

![在这里插入图片描述][20191220191310893.png]

#### 关联集合 ####

集合之间默认是没有关联的，通常一些不同集合之间的数据之间有着某种关系，比如文章信息和文章作者的信息存储在不同集合中，但是文章是某个用户发表的，要查询文章的作者信息，就需要用到关联集合。

集合之间一般是使用 id 进行关联关联，然后通过 populate() 方法进行关联集合查询。

示例：

// 引入 mongoose 操作数据库
    const mongoose = require('mongoose')
    // 连接数据库
    mongoose
      .connect('mongodb://localhost/userInfo', { 
        useNewUrlParser: true,
        useUnifiedTopology: true
      })
      // 连接成功
      .then(() => console.log('数据库连接成功'))
      // 连接失败
      .catch(err => console.log(err, '数据库连接失败'))
    
    // 设计用户集合结构
    const userSchema = new mongoose.Schema({ 
      name: { 
        type: String,
        required: true
      }
    })
    // 设计文章集合结构
    const postSchema = new mongoose.Schema({ 
      title: { 
        type: String
      },
      author: { 
        // 通过 id 与用户集合进行关联
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
      }
    })
    // 应用用户集合
    const User = mongoose.model('User', userSchema)
    // 应用文章集合
    const Post = mongoose.model('Post', postSchema)
    
    // 创建用户文档
    User.create({  name: 'boy' }).then(result => console.log(result))
    // 创建文章文档
    Post.create({  titile: 'www', author: '5dfcb365bf9f50355c0e299a' }).then(
      result => console.log(result)
    )
    // 关联查询
    Post.find()
      .populate('author')
      .then(result => console.log(result))

[https_github.com_mongodb_node-mongodb-native]: https://github.com/mongodb/node-mongodb-native
[https_mongoosejs.com_]: https://mongoosejs.com/
[mongoose.connect_uri_ option_ callback]: http://www.mongoosejs.net/docs/connections.html
[Schema_definition_options]: http://www.mongoosejs.net/docs/api.html#schema_Schema
[mongoose.model_name_schema]: http://www.mongoosejs.net/docs/models.html
[Model.prototype.save_options_options.safe_options.validateBeforeSave_fn_]: http://www.mongoosejs.net/docs/api.html#model_Model-save
[Model.create_doc_callback]: http://www.mongoosejs.net/docs/api.html#create_create
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ4NjUzOQ_size_16_color_FFFFFF_t_70]: /images/20211201/884346f8b1c54a84a8c1919638098820.png
[Model.find_conditions_callback]: http://www.mongoosejs.net/docs/api.html#find_find
[Model.findOne_conditions_callback]: http://www.mongoosejs.net/docs/api.html#findone_findOne
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ4NjUzOQ_size_16_color_FFFFFF_t_70 1]: /images/20211201/4744032ef48f4d2fa7d05ef3501920fb.png
[select_arg]: http://www.mongoosejs.net/docs/api.html#query_Query-select
[sort_arg]: http://www.mongoosejs.net/docs/api.html#query_Query-sort
[skip_val]: http://www.mongoosejs.net/docs/api.html#query_Query-skip
[limit_val]: http://www.mongoosejs.net/docs/api.html#query_Query-limit
[findOneAndDelete_conditions_callback]: https://mongoosejs.com/docs/api/query.html#query_Query-findOneAndDelete
[findOneAndRemove]: http://www.mongoosejs.net/docs/api.html#query_Query-findOneAndRemove
[deleteMany_filter_callback]: http://www.mongoosejs.net/docs/api.html#query_Query-deleteMany
[20191220152450910.png]: /images/20211201/3e50de8c1dd24f749bab6248f0ff1070.png
[updateOne_criteria_doc_callback]: http://www.mongoosejs.net/docs/api.html#query_Query-updateOne
[fandOneAndUpdate]: http://www.mongoosejs.net/docs/api.html#query_Query-findOneAndUpdate
[20191220155722509.png]: /images/20211201/efda650b80df461a828030baa70a402c.png
[updateMany]: http://www.mongoosejs.net/docs/api.html#query_Query-updateMany
[20191220160620768.png]: /images/20211201/26ea67890a984ce8b62122fa5c69b644.png
[20191220191310893.png]: /images/20211201/925cb129becd47a495c9c420801b9051.png