mongoose官方文档总结

// 1，引入mongoose
const mongoose = require('mongoose')
// 2. 连接本地数据库
let db = mongoose.connect('mongodb://localhost/test')

const db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  // we're connected!
});

let tomSchema = mongoose.Schema({
	name:String
})

//接着，把这个Schema编译成一个Model
let Tom = mongoose.model('Tom',tomSchema)

// 给这个model加一个code方法
Tom.methods.code = function(){
	let nickname = this.name ? "The programmar name is :" + this.name:'I don't have name'
  console.log(nickname)
}

//model是我们构造document的class，每个document都是一个Tom对象
let Tomliu = new Tom({name:'liugezhou'})
Tomliu.code() //The programmar name is :liugezhou

// save
Tomliu.save(function(err,item){
	if (err) return console.error(err);
   item.speak();
})

// 获取所有的Tom
Tom.find(function(err,tomlius){
	if(err) return console.error(err);
  console.log(tomlius)
})

//获取特定数据
Tom.find({name:/^liugezhou/},callback)

const animalSchema = mongoose.Schema({type:String,name:String})

animalSchema.methods.findSameType = function (cb){
  return this.model('Animal').find(type:this.type,cb)
}

const Animal = mongoose.model('Animal',animalSchema)
const dog = new Animal({type:'dog'})

dog.findSameType(function(err,dogs){
	console.log(dogs)
})

animalSchema.statics.findByName = function(name,cb) {
	return this.find({name:new RegExp(name,'i')},cb)
}
const Animal = mongoose.model('Animal',animalSchema)
Animal.findByName('fido',function(err,animal){
	console.log(animals)
})

animalSchema.query.byName = function(name) {
  return this.find({ name: new RegExp(name, 'i') });
};

var Animal = mongoose.model('Animal', animalSchema);
Animal.find().byName('fido').exec(function(err, animals) {
  console.log(animals);
});

var animalSchema = new Schema({
  name: String,
  type: String,
  tags: { type: [String], index: true } // field level
});

animalSchema.index({ name: 1, type: -1 }); // schema level

// define a schema
var personSchema = new Schema({
  name: {
    first: String,
    last: String
  }
});

// compile our model
var Person = mongoose.model('Person', personSchema);

// create a document
var axl = new Person({
  name: { first: 'Axl', last: 'Rose' }
});

console.log(axl.name.first + ' ' + axl.name.last); // Axl Rose

personSchema.virtual('fullName').get(function () {
  return this.name.first + ' ' + this.name.last;
});

console.log(axl.fullName); // Axl Rose

personSchema.virtual('fullName').
  get(function() { return this.name.first + ' ' + this.name.last; }).
  set(function(v) {
    this.name.first = v.substr(0, v.indexOf(' '));
    this.name.last = v.substr(v.indexOf(' ') + 1);
  });

axl.fullName = 'William Rose'; // Now `axl.name.first` is "William"

new Schema({..}, options);

// or

var schema = new Schema({..});
schema.set(option, value);

var schema1 = new Schema({
  test: String // `test` is a path of type String
});

var schema2 = new Schema({
  test: { type: String } // `test` is a path of type string
});

var shema2 = new Schema({
	test:{
  	type:String,
    lowercase:true
  }
})

var schema = new mongoose.Schema({ name: 'string', size: 'string' });
var Tank = mongoose.model('Tank', schema);

const Tank = mongoose.model('Tank',TankSchema)
const small = new Tank({ size:' small'})
small.save(function(err){
	if (err) return hanldeError(err) 
})

// or
Tank.create({size:'small'},function(err,small){
	if (err) return handleError(err)
})

Tank.remove({size:small},function(err){
	if(err) return handler(err)
})

Tank.findById(id,function(err,tank){
	if (err) return handlerError(err)
  
  tank.size = 'large';
  //tank.set({size:'large'})
  tank.save(function(err,updateTank){
  	if (err) return handlerError(err)
    res.send(updateTank)
  })
})

Tank.findByIdAndUpdate(id,{$set:{size:'large'}},{new:true},function(err,tank){
  if (err) return handlerError(err)
  res.send(tank)
})

const chidlSchema = new Schema({name:String})

const parentSchema =  new Schema({
	children:[childSchema],
  child:childSchema
})

const Parent = mongoose.model('Parent',parentSchema)
const parent = new Parent({children:[{name:'liu'},{name:'ge'},{name:'zhou;}]})
parent.children[0].name = 'liu'       
parent.save(callback)         

const Person = mpngoose.model('Pseron',PersonSchema);

Person.findOne({name.last:'Ghost'},'name occupation',function(err,person){
	if(err) return handleError(err)
  console.log('%s %s is a %s',person.name.fisrt,person.name.last,person.occupation)
})

const schema = new Schema(..);
schema.pre('save',function(next){
	// to stuff
  next()
})

schema.pre('save',function(){
	return doStuff().
					then(()=> doMoreStuff())
})

// or

shcema.pre('save',async function(){
	await doStuff();
  await doMoreStuff();
})

const schema = new Schema(..)

shcema.pre('save',true,function(next,done){
	next()
  setTimeout(done,100)
})

schema.post('init',function(doc){
	 console.log('%s has been initialized from the db', doc._id);
})

schema.post('validate',function(doc){
	 console.log('%s has been validated (but not saved yet)', doc._id);
})

schema.post('save',function(doc){
   console.log('%s has been saved', doc._id);
})

schema.post('remove',function(doc){
	 console.log('%s has been removed', doc._id);
})

schema.post('save',function(doc,next){
	setTimeout(function(){
  	console.log('pot1')
    next()
  },100)
})

schema.post('save', function(doc, next) {
  console.log('post2');
  next();
});

schema.pre('find',function(){
	conosle.log(this instanceof mongoose.query) //true
  this.start = Date.now()
})

schema.post('find',function(result){
	conosle.log(this instanceof mongoose.query) //true
  // prints returned documents
  console.log('find() returned ' + JSON.stringify(result));
  // prints number of milliseconds the query took
  console.log('find() took ' + (Date.now() - this.start) + ' millis');
})

const schema = new Schema({
	name:{
  	type:String,
    unique:true
  }
})

schema.post('save',function(err,doc,next){
  if (error.name === 'MongoError' && error.code === 11000) {
    next(new Error('There was a duplicate key error'));
  } else {
    next(error);
  }
})

Person.create([{name:'liu'},{name:'Gezhou'}]);

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

const personSchema = Schema({
	_id:Schema.types.ObjectId,
  name:String,
  age:Number,
  stories:[{type:Schema.types.ObjectId,ref:'Story'}]
})

const storySchema = Schema({
	author:{type:Schema.types.ObjectId,ref:'Person'},
  title:String,
  fans:[{type:Schema.types.ObjectId,ref:'Person'}]
})

const Story = mongose.model('Story',storySchema)
const Person = mongose.model('Person',personSchema)

const author = new Person({
	_id:new mongoose.Types.objectId(),
  name:'liugezhou',
  age:18
})

author.save(function(err){
	if (err) return handleError(err);
  const story1 = new Story({
  	title:'my book',
    author:author._id
  })
  story1.save(function(err){
  	if (err) return handleError(err);
  })
})

Story.
	findOne({title:'my book'}).
	populate('author').
	exec(function(err,story){
		if (err) return handleError(err);
  	console.log('The author is %s', story.author.name);
	})

Story.findOne({title:'my book'},function(err,story){
	if (err) return handleError(err);
  
  story.author = author
  console.log(story.author.name);
})