目录参考

db.js ------------封装用作连接的数据库

//引入mongoose
const mongoose = require('mongoose')
const DB_URL = "mongodb://localhost:27017/msc2021"

// 连接数据库
mongoose.connect(DB_URL, { useNewUrlParser: true, useUnifiedTopology: true })

// 检测数据库的连接状态
mongoose.connection.once('open', () => {
  console.log('数据库连接成功')
})

mongoose.connection.on('error', () => {
  console.error.bind(console, 'connection error:')
})
module.exports = mongoose

User.js ------------nodejs实现集合的创建

const mongoose = require('../db')

const schema = new mongoose.Schema({
  userid: { type: String },
  username: { type: String },
  password: { type: String },
  tel: { type: String },
  telcode: { type: String },
  email: { type: String },
  nickname: { type: String },
  qq: { type: String },
  wx: { type: String },
  avatar: { type: String },
  sex: { type: Number }, // 1 男  0 女
  birthday: { type: String },
})

module.exports = mongoose.model('User', schema)

Product.js ------------nodejs实现集合的创建

const mongoose = require('../db')
const schema = new mongoose.Schema({
  proid: String, // 产品id，每个产品的唯一值
  category: String, // 产品分类
  brand: String, // 产品品牌
  proname: String, // 产品名称
  banners: Array, // 产品详情中的轮播图/放大镜
  originprice: Number, // 产品原价
  sales: Number, // 产品销量
  stock: Number, // 产品库存
  desc: String, // 产品描述
  issale: Number, // 是否在售卖
  isrecommend: Number, // 当前产品是否被推荐
  discount: Number, // 产品价格折扣
  isseckill: Number, // 是否参加秒杀
  img1: String, // 产品的单图图片1
  img2: String, // 产品的单图图片2
  img3: String, // 产品的单图图片3
  img4: String // 产品的单图图片4
})
module.exports = mongoose.model('Product', schema)

Cart.js ------------nodejs实现集合的创建

const mongoose =require('../db')
const schema =new mongoose.Schema({
  cartid: String,
  userid: String,
  proid: String,
  flag: Boolean,
  num:Number,
})

module.exports = mongoose.model('Cart',schema)

index.js ------------增删改查分页等等的封装

module.exports = {
  insert (collectionName, insertData) {
    // 采用 es6的promise 解决异步操作问题
    // https://es6.ruanyifeng.com/#docs/promise
    return new Promise((resolve, reject) => {
      collectionName.insertMany(insertData, err => {
        if (err) {
          reject(err)
        } else {
          resolve()
        }
      })
    })
  },
  delete (collectionName, whereData, deleteNum) {
    const deleteType = deleteNum === 1 ? 'deleteMany' : 'deleteOne'
    return new Promise((resolve, reject) => {
      collectionName[deleteType](whereData, (err) => {
        if (err) {
          reject(err)
        } else {
          resolve()
        }
      })
    }) 
  },
  update (collectionName, whereData, updateData, updateNum) {
    // updateOne
    // updateMany
    const updateType = updateNum === 1 ? 'updateMany' : 'updateOne'
    return new Promise((resolve, reject) => {
      collectionName[updateType](whereData, updateData, (err) => {
        if (err) {
          reject(err)
        } else {
          resolve()
        }
      })
    })
  },
  find (collectionName, whereData, showData) {
    return new Promise((resolve, reject) => {
      // collectionName.find(whereData, showData, (err, data) => {
      //   if (err) {
      //      reject(err)
      //   } else {
      //     resolve(data)
      //   }
      // })
      collectionName.find(whereData, showData).exec((err, data) => {
        if (err) {
           reject(err)
        } else {
          resolve(data)
        }
      })
    })
  },
  paging (collectionName, whereData, showData, count, limitNum) {
    return new Promise((resolve, reject) => {
      collectionName.find(whereData, showData)
      .limit(limitNum)
      .skip((count - 1) * limitNum)
      .exec((err, data) => {
        if (err) {
          reject(err)
        } else {
          resolve(data)
        }
      })
    })
  },
  sort (collectionName, whereData, showData, sortData) {
    return new Promise((resolve, reject) => {
      // Search.find({}, { _id:0, __v: 0}).sort({num: -1})
      collectionName.find(whereData, showData).sort(sortData).exec((err, data) => {
        if (err) {
          reject(err)
        } else {
          resolve(data)
        }
      })
    })
  },
  distinct(collectionName, type) {
    return new Promise((resolve, reject) => {
      collectionName.distinct(type).exec((err, data) => {
        if (err) {
          reject(err)
        } else {
          resolve(data)
        }
      })
    })
  }
}