mongoose 学习之路（一）

80530895

2019-06-26

我们先来上一个直观的例子吧：

第一次使用 mongoose

// 目录结构
-model
    -db.js             // 链接数据库
    -test1.js          // 定义模型
- app.js
- package.json

安装mongoose

cnpm install mongoose --save

// db.js
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/test'); // 链接test数据库

var db = mongoose.connection;  

db.on('error', console.error.bind(console, 'connection error:')); // 连接失败

// 连接成功
db.on('open', function(){
  console.log('链接成功！！');
})

module.exports = db; // 导出

// test1.js

var mongoose = require('mongoose')

var db = require('./db.js')        // 引入数据库连接文件

// 创建 TestSchema
var TestSchema = new mongoose.Schema({
  name: { type: String },
  age: { type: Number, default: 0 },
  email: { type: String },
  time: { type: Date, default: Date.now }
});

//建立模型
var TestModel = db.model("test1", TestSchema); 

// 导出模型
module.exports = TestModel;

// app.js
var db = require("./model/db.js");
var TestModel = require('./model/test1.js');

// 实例化一个模型
var TestEntity = new TestModel({
  name: "zjj",
  age: 28,
  email: "helloworld@qq.com"
});


// 调用本身mongoose 自带的实例打方法 save() 存到数据库中
TestEntity.save(function (error, doc) {
  if (error) {
    console.log("error :" + error);
  } else {
    console.log(doc);
    // 打印出存入的内容
  }
});

mongoose是nodeJS提供连接 mongodb的一个库！

连接mongoose

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/test');
const con = mongoose.connection;
con.on('error', console.error.bind(console, '连接数据库失败'));
con.once('open',()=>{
    //成功连接
})

在mongoose 中大致有这么几个概念：

Schema: 相当于一个数据库的模板. Model可以通过mongoose.model 集成其基本属性内容. 当然也可以选择不继承.
Model: 基本文档数据的父类,通过集成Schema定义的基本方法和属性得到相关的内容.
instance: 这就是实实在在的数据了. 通过 new Model()初始化得到.

她们各自之间的关系是什么呢？
mongoose 学习之路（一）

首先我们来先学习 Schema

schemas

定义你的schema

mongoose 一切源于一个schema. 每一个 schema 映射到 MongoDB 的集合和定义该结合中的文档形式。

var mongoose = require('mongoose');
var Schema = mongoose.Schema();

// new 一个 Schema 得到  blogSchema
var blogSchema = new Shema({
    title: String,
    author: String,
    body: String,
    comments: [{body: String, date: Date}],
    hidden: Boolean,
    meta: {
        votes: Number,
        favs: Number
    }
});

我们代码中的每一个 key 定义了我们文档中的每一个属性，该属性将转换为其关联的 SchemaType 。

SchemaType ：

String
Number
Date
Buffer
Boolean
Mixed
ObjectId
Array

SchemaTypes实例

// 一个schema实例
var TestSchema = new mongoose.Schema({
  name:    String,    
  binary:  Buffer,
  living:  Boolean,
  updated: { type: Date, default: Date.now },
  age:     { type: Number, min: 18, max: 65 },
  mixed:   Schema.Types.Mixed,
  _someId: Schema.Types.ObjectId,
  array:      [],
  ofString:   [String],
  ofNumber:   [Number],
  ofDates:    [Date],
  ofBuffer:   [Buffer],
  ofBoolean:  [Boolean],                
  ofMixed:    [Schema.Types.Mixed],
  ofObjectId: [Schema.Types.ObjectId],
  nested: {                                // 对象中包含对象
    stuff: { type: String, lowercase: true, trim: true }
  }
});


// 使用实例
var TestEntity = new TestModel({
  name: 'zjj',
  age: 45,
  updated: new Date(),
  binary : new Buffer(0),
  living: false,
  mixed: { any: { thing: 'i want', assd:'sada' } },
  _someId: new mongoose.Types.ObjectId,
  array: [1,2,3],
  ofString: ['sad','sada'],
  ofNumber: [1,2,3,4,5,],
  ofDates: [new Date,new Date(2017/4/23)],
  ofMixed: [1,'sad',{sda:'dsada'}],
  ofBoolean: [true, false, true],
  nested: {
      stuff: 'dsad'  
  },
  ofBuffer: [new Buffer(0)]
});



// 储存结果是
/* 7 */
{
    "_id" : ObjectId("5abb529645f6673964cc54f5"),
    "nested" : {
        "stuff" : "dsad"
    },
    "array" : [ 
        1, 
        2, 
        3
    ],
    "ofString" : [ 
        "sad", 
        "sada"
    ],
    "ofNumber" : [ 
        1, 
        2, 
        3, 
        4, 
        5
    ],
    "ofDates" : [ 
        ISODate("2018-03-28T08:30:14.252Z"), 
        ISODate("1970-01-01T00:00:00.021Z")
    ],
    "ofBuffer" : [ 
        { "$binary" : "", "$type" : "00" }
    ],
    "ofBoolean" : [ 
        true, 
        false, 
        true
    ],
    "ofMixed" : [ 
        1, 
        "sad", 
        {
            "sda" : "dsada"
        }
    ],
    "ofObjectId" : [],
    "name" : "zjj",
    "age" : 45,
    "updated" : ISODate("2018-03-28T08:30:14.252Z"),
    "binary" : { "$binary" : "", "$type" : "00" },
    "living" : false,
    "mixed" : {
        "any" : {
            "thing" : "i want",
            "assd" : "sada"
        }
    },
    "_someId" : ObjectId("5abb529645f6673964cc54f4"),
    "__v" : 0
}

我们来看一下几个比较重要的类型：

Date

使用内置的Date 日期类型时，如果你在文档中使用 Date 内置的 setMonth 之类的方法来修改它，那么mongoose 是不会意识到它的改变的。你必须使用 doc.markModified 方法来告诉mongoose 这个改变。

var Assignment = mongoose.model('Assignment', { dueDate: Date });
Assignment.findOne(function (err, doc) {
  doc.dueDate.setMonth(3);
  doc.save(callback);     // 设置月份没有效果

  doc.markModified('dueDate');    //告诉 mongoose 需要修改 dueDate
  doc.save(callback); // works
});

Mixed

混合型是一种存啥都行的类型，Mixed 类型用户 Schema.Types.Mixed 或者是一个字面上的对象 {} 来定义。

// 这两种是等价的定义方式
var Any = new Schema({ any: {} });
var Any = new Schema({ any: Schema.Types.Mixed });
// Schema 类型定义

Mixed类型在修改时时候必须使用 doc.markModified 方法来告诉mongoose某个混合类型的值被改变了。

person.anything = { x: [3, 4, { y: "changed" }] };
person.markModified('anything');
person.save(); // 这样才能储存成功

ObjectId

用Schema.Types.ObjectId 来声明一个对象id类型。

var mongoose = require('mongoose');
var ObjectId = mongoose.Schema.Types.ObjectId;
// Schema 类型定义
var Car = new Schema({ driver: ObjectId });

数组类型

数组内部可以是各种类型

var TestSchema = new mongoose.Schema({
  array:      [],
  ofString:   [String],
  ofNumber:   [Number],
  ofDates:    [Date],
  ofBuffer:   [Buffer],
  ofBoolean:  [Boolean],
  ofMixed:    [Schema.Types.Mixed],
  ofObjectId: [Schema.Types.ObjectId]
});

// 储存
  array: [1,2,3,'dasda'],
  ofString: ['sad','sada'],
  ofNumber: [1,2,3,4,5,],
  ofDates: [new Date,new Date(2017/4/23)],
  ofMixed: [1,'sad',{sda:'dsada'}],
  ofBoolean: [true, false, true]

自定义的模式类型

除了上面的几种数据类型之外，还可以自己定义自己的模式类型
这里就先不总结了，需要时查看文档即可了。

创建一个基本的自定义模式类型