Mongoose 是一个面向 MongoDB 数据库的对象数据模型（ODM）库，用于在 Node.js 环境下建模和操作 MongoDB 文档结构。它提供了一些方便的特性，如数据验证、查询构建、业务逻辑钩子（hooks）和中间件，使得处理 MongoDB 文档更加直观和安全。


Mongoose

在Mongoose中，时间戳通常适用于想要自动记录文档创建和最后修改时间的场景。启用时间戳的模式选项会为你的文档添加两个字段：`createdAt` 和 `updatedAt`。`createdAt` 字段会在文档首次保存到数据库时设置，而 `updatedAt` 字段会在每次调用 `save()` 方法更新文档时自动更新。

以下是使用时间戳的适合场景：

1. **用户账户系统**：在用户账户系统中，可以通过时间戳轻松追踪用户账户的创建时间和上次更新时间，这对于审计和监控账户行为很有帮助。

2. **日志记录**：如果你正在构建一个需要日志记录的系统，如错误日志或用户活动日志，时间戳是记录事件发生时间的理想方式。

3. **内容管理系统** (CMS)：在CMS中，内容项（如文章、页面或评论）通常需要记录发布和编辑的时间戳，以便追踪内容的版本和历史。

4. **电子商务平台**：在订单管理中，记录订单创建和修改时间对于订单处理流程和客户服务至关重要。

5. **博客平台**：博客文章通常会展示发布和最后修改的日期，通过时间戳可以自动化这一过程。

6. **任务跟踪系统**：在任务或票据等跟踪系统中，了解任务何时被创建和最后更新对于项目管理非常重要。

下面是一个启用时间戳的Mongoose模式的示例：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

const UserSchema = new Schema(
  {
    username: {
      type: String,
      required: true
    },
    email: {
      type: String,
      required: true,
      unique: true
    },
    password: {
      type: String,
      required: true
    }
    // 其他字段...
  },
  {
    timestamps: true // 启用时间戳
  }
);

const User = mongoose.model('User', UserSchema);

// 当你使用 User 模型创建新用户时，Mongoose会自动设置 createdAt 和 updatedAt 字段。
```

在这个用户账户模型示例中，启用时间戳选项后，每个用户文档都将自动包含 `createdAt` 和 `updatedAt` 字段，这可以帮助我们跟踪用户的注册时间以及他们信息的最后更新时间。如果以后需要对用户表进行数据分析或维护，这些时间戳将非常有用。

**Edit - 20 March 2016**

Mongoose now support [timestamps for collections](https://github.com/Automattic/mongoose/blob/master/History.md#4111--2015-10-12).

Please consider the [answer of @bobbyz below](https://stackoverflow.com/a/34398826/1139105). Maybe this is what you are looking for.

Original answer
===============

Mongoose supports a `Date` type (which is basically a timestamp):

    time : { type : Date, default: Date.now }
    

With the above field definition, any time you save a document with an unset `time` field, Mongoose will fill in this field with the current time.

Source: [http://mongoosejs.com/docs/guide.html](http://mongoosejs.com/docs/guide.html)

The current version of Mongoose (v4.x) has time stamping as a built-in option to a schema:

    var mySchema = new mongoose.Schema( {name: String}, {timestamps: true} );
    

This option adds `createdAt` and `updatedAt` properties that are timestamped with a `Date`, and which does all the work for you. Any time you update the document, it updates the `updatedAt` property. [Schema Timestamps Docs.](http://mongoosejs.com/docs/guide.html#timestamps)

In case you want custom names for your `createdAt` and `updatedAt`

    const mongoose = require('mongoose');  
    const { Schema } = mongoose;
        
    const schemaOptions = {
      timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
    };
    
    const mySchema = new Schema({ name: String }, schemaOptions);

var ItemSchema = new Schema({
        name : { type: String }
    });
    
    ItemSchema.set('timestamps', true); // this will add createdAt and updatedAt timestamps
    

Docs: [https://mongoosejs.com/docs/guide.html#timestamps](https://mongoosejs.com/docs/guide.html#timestamps)

Mongoose now supports the timestamps in schema.

    const item = new Schema(
      {
        id: {
          type: String,
          required: true,
        },
      { timestamps: true },
    );
    

This will add the `createdAt` and `updatedAt` fields on each record create.

Timestamp interface has fields

      interface SchemaTimestampsConfig {
        createdAt?: boolean | string;
        updatedAt?: boolean | string;
        currentTime?: () => (Date | number);
      }
    

This would help us to choose which fields we want and overwrite the date format.

Mongoose 中哪种 schema 类型适合使用时间戳？

在使用Mongoose进行分页查询时，通常需要两个参数：`page`（当前页码）和`limit`（每页显示的记录数）。页码和记录数可以让我们计算出需要跳过多少条记录来获取当前页的数据。

这里有一个基础的例子，演示了怎样实现分页：

假设我们有一个模型 `Item`，我们需要实现一个查询来获取第 `page` 页的数据，每页显示 `limit` 条记录。

```javascript
const page = req.query.page; // 从请求中获取页码
const limit = req.query.limit; // 从请求中获取每页显示的记录数

const options = {
  page: parseInt(page, 10) || 1, // 设置默认页码为1
  limit: parseInt(limit, 10) || 10, // 设置默认每页显示记录数为10
};

// 计算跳过多少条记录
const skip = (options.page - 1) * options.limit;

// 分页查询
Item.find()
  .skip(skip)
  .limit(options.limit)
  .exec((err, items) => {
    if (err) {
      // 处理错误
    } else {
      // 处理查询结果
    }
  });
```

在上面的代码中，我们首先从请求中获取页码和每页记录数。然后，我们计算出需要跳过的记录数，这是通过将当前页码减去1，然后乘以每页的记录数来实现的。这个值就是 `.skip()` 方法需要的参数。`.limit()` 方法则告诉Mongoose每页需要获取的记录数。

这样，每次调用这个分页查询，你只需要传递相应的 `page` 和 `limit` 参数即可。如果用户没有提供这些参数，我们会使用默认值。

值得注意的是，这种方法适用于数据量不是非常大时的分页。当处理大量数据时，每次都用 `.skip()` 和 `.limit()` 方法可能会导致性能问题，因为 `.skip()` 实际上是通过读取并跳过前面的记录来实现的，这在记录数非常多的时候可能很慢。解决这个问题的一种方法是使用类似于 "无限滚动" 的策略，根据最后加载的记录的ID来获取下一批记录。

I suggest you to use 2 queries:

1.  `db.collection.count()` will return total number of items. This value is stored somewhere in Mongo and it is not calculated.
    
2.  `db.collection.find().skip(20).limit(10)` here I assume you could use a sort by some field, so do not forget to add an index on this field. This query will be fast too.
    

I think that you shouldn't query all items and than perform skip and take, cause later when you have big data you will have problems with data transferring and processing.

Instead of using 2 separate queries, you can use `aggregate()` in a single query:

Aggregate **"$facet"** can be fetch more quickly, the _**Total Count**_ and the _**Data with skip & limit**_

        db.collection.aggregate([
    
          //{$sort: {...}}
    
          //{$match:{...}}
    
          {$facet:{
    
            "stage1" : [ {"$group": {_id:null, count:{$sum:1}}} ],
    
            "stage2" : [ { "$skip": 0}, {"$limit": 2} ]
      
          }},
         
         {$unwind: "$stage1"},
      
          //output projection
         {$project:{
            count: "$stage1.count",
            data: "$stage2"
         }}
    
     ]);
    

**output as follows:-**

    [{
         count: 50,
         data: [
            {...},
            {...}
          ]
     }]
    

Also, have a look at [https://docs.mongodb.com/manual/reference/operator/aggregation/facet/](https://docs.mongodb.com/manual/reference/operator/aggregation/facet/)

db.collection_name.aggregate([
        { '$match'    : { } },
        { '$sort'     : { '_id' : -1 } },
        { '$facet'    : {
            metadata: [ { $count: "total" } ],
            data: [ { $skip: 1 }, { $limit: 10 },{ '$project' : {"_id":0} } ] // add projection here wish you re-shape the docs
        } }
    ] )
    

Instead of using two queries to find the total count and skip the matched record.  
$facet is the best and optimized way.  

1.  Match the record  
    
2.  Find total\_count  
    
3.  skip the record  
    
4.  And also can reshape data according to our needs in the query.

There is a library that will do all of this for you, check out [mongoose-paginate-v2](https://github.com/aravindnc/mongoose-paginate-v2)

You don't have to use two queries or one complicated query with aggregate and such.

You can use one query

example:

    const getNames = async (queryParams) => {
    
      const cursor = db.collection.find(queryParams).skip(20).limit(10);
      return {
        count: await cursor.count(),
        data: await cursor.toArray()
      }
      
    }
    

mongo returns a cursor that has predefined functions such as count, which will return the full count of the queried results regardless of skip and limit

So in count property, you will get the full length of the collection and in data, you will get just the chunk with offset of 20 and limit of 10 documents

Mongoose 分页查询时如何设置页码？

在Node.js中实现面向对象编程（OOP）的方法主要是通过使用JavaScript的类和原型继承特性。以下是实现OOP的几个步骤：

### 1. 定义类

在ES6中引入了`class`关键字，可以使定义类更加直观。类是对象的蓝图，可以定义属性和方法。

```javascript
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}
```

### 2. 创建对象实例

使用`new`关键字从类创建对象实例。

```javascript
const person1 = new Person('Alice', 30);
person1.greet(); // 输出: Hello, my name is Alice and I am 30 years old.
```

### 3. 继承

可以通过`extends`关键字使一个类继承另一个类的特性。

```javascript
class Employee extends Person {
  constructor(name, age, jobTitle) {
    super(name, age); // 调用父类的构造器
    this.jobTitle = jobTitle;
  }

  work() {
    console.log(`${this.name} is working as a ${this.jobTitle}.`);
  }
}

const employee1 = new Employee('Bob', 25, 'Software Developer');
employee1.greet();   // 输出: Hello, my name is Bob and I am 25 years old.
employee1.work();    // 输出: Bob is working as a Software Developer.
```

### 4. 封装

封装是OOP中的一个核心概念，意味着将对象的状态和行为包含在内部，并只暴露有限的接口与外界通信。

```javascript
class BankAccount {
  #balance; // 私有属性，使用 # 标记

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  deposit(amount) {
    if (amount > 0) {
      this.#balance += amount;
    }
  }

  withdraw(amount) {
    if (amount <= this.#balance) {
      this.#balance -= amount;
    }
  }

  getBalance() {
    return this.#balance;
  }
}

const account = new BankAccount(1000);
account.deposit(500);
console.log(account.getBalance()); // 输出: 1500
```

在这个例子中，`#balance`是一个私有属性，它不可以直接从类的外部访问，而只能通过类的方法来操作。

### 5. 多态

多态性意味着子类可以定义一个与父类相同的方法，但具有不同的行为。

```javascript
class Animal {
  speak() {
    console.log('Animal speaks');
  }
}

class Dog extends Animal {
  speak() {
    console.log('Woof woof');
  }
}

const animal = new Animal();
const dog = new Dog();

animal.speak(); // 输出: Animal speaks
dog.speak();    // 输出: Woof woof
```

在这个例子中，`Dog`类重写了`Animal`类的`speak`方法，实现了多态。

通过这些步骤，我们可以在Node.js中实现面向对象编程的基本概念，包括类的定义、继承、封装和多态。这些原则有助于组织和模块化代码，使其更易于理解和维护。

This is an example that works out of the box. If you want less "hacky", you should use inheritance library or such.

Well in a file animal.js you would write:

    var method = Animal.prototype;
    
    function Animal(age) {
        this._age = age;
    }
    
    method.getAge = function() {
        return this._age;
    };
    
    module.exports = Animal;
    

To use it in other file:

    var Animal = require("./animal.js");
    
    var john = new Animal(3);
    

If you want a "sub class" then inside mouse.js:

    var _super = require("./animal.js").prototype,
        method = Mouse.prototype = Object.create( _super );
    
    method.constructor = Mouse;
    
    function Mouse() {
        _super.constructor.apply( this, arguments );
    }
    //Pointless override to show super calls
    //note that for performance (e.g. inlining the below is impossible)
    //you should do
    //method.$getAge = _super.getAge;
    //and then use this.$getAge() instead of super()
    method.getAge = function() {
        return _super.getAge.call(this);
    };
    
    module.exports = Mouse;
    

Also you can consider "Method borrowing" instead of vertical inheritance. You don't need to inherit from a "class" to use its method on your class. For instance:

     var method = List.prototype;
     function List() {
    
     }
    
     method.add = Array.prototype.push;
    
     ...
    
     var a = new List();
     a.add(3);
     console.log(a[0]) //3;

As Node.js community ensure new features from the JavaScript ECMA-262 specification are brought to Node.js developers in a timely manner.

You can take a look at **JavaScript classes**. [MDN link to JS classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) In the ECMAScript 6 JavaScript classes are introduced, this method provide easier way to model OOP concepts in Javascript.

**Note** : JS classes will work in only **strict mode**.

Below is some skeleton of class,inheritance written in Node.js ( Used Node.js Version **v5.0.0** )

**Class declarations :**

    'use strict'; 
    class Animal{
    
     constructor(name){
        this.name = name ;
     }
    
     print(){
        console.log('Name is :'+ this.name);
     }
    }
    
    var a1 = new Animal('Dog');
    

**Inheritance :**

    'use strict';
    class Base{
    
     constructor(){
     }
     // methods definitions go here
    }
    
    class Child extends Base{
     // methods definitions go here
     print(){ 
     }
    }
    
    var childObj = new Child();

I suggest to use the `inherits` helper that comes with the standard `util` module: [http://nodejs.org/api/util.html#util\_util\_inherits\_constructor\_superconstructor](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor)

There is an example of how to use it on the linked page.

This is the best video about Object-Oriented JavaScript on the internet:

[The Definitive Guide to Object-Oriented JavaScript](https://www.youtube.com/watch?v=PMfcsYzj-9M)

Watch from beginning to end!!

Basically, Javascript is a [Prototype-based](https://en.wikipedia.org/wiki/Prototype-based_programming) language which is quite different than the classes in Java, C++, C#, and other popular friends. The video explains the core concepts far better than any answer here.

With ES6 (released 2015) we got a "class" keyword which allows us to use Javascript "classes" like we would with Java, C++, C#, Swift, etc.

Screenshot from the video showing how to write and instantiate a Javascript class/subclass: [![enter image description here](https://i.stack.imgur.com/gZlB4.png)](https://en.wikipedia.org/wiki/Prototype-based_programming)

In the Javascript community, lots of people argue that OOP should not be used because the prototype model does not allow to do a strict and robust OOP natively. However, I don't think that OOP is a matter of langage but rather a matter of architecture.

If you want to use a real strong OOP in Javascript/Node, you can have a look at the full-stack open source framework [Danf](https://github.com/gnodi/danf). It provides all needed features for a strong OOP code (classes, interfaces, inheritance, dependency-injection, ...). It also allows you to use the same classes on both the server (node) and client (browser) sides. Moreover, you can code your own danf modules and share them with anybody thanks to Npm.

Nodejs 中的如何实现 oop 面向对象编程？

Mongoose 是一个 MongoDB 对象文档模型（ODM）库，它提供了一种在 Node.js 环境中优雅地处理 MongoDB 数据库的方式。在 Mongoose 中，一个集合通常通过一个模型来表示，这个模型定义了文档的结构和它们的行为。

要从 Mongoose 集合中删除所有文档，您可以使用模型的 `deleteMany()` 函数，无需指定过滤条件，就可以删除所有匹配的文档。下面是一个如何使用 `deleteMany()` 函数的示例：

```javascript
// 引入 Mongoose 和连接到数据库
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/mydatabase', {useNewUrlParser: true, useUnifiedTopology: true});

// 定义模型和模式
const Schema = mongoose.Schema;
const mySchema = new Schema({
    // 定义文档的结构...
});
const MyModel = mongoose.model('MyCollection', mySchema);

// 删除集合中的所有文档
MyModel.deleteMany({}, (err) => {
    if (err) {
        console.error('发生错误:', err);
    } else {
        console.log('成功删除集合中的所有文档。');
    }
});
```

在这个例子中，`MyModel` 表示连接到 MongoDB 数据库中名为 `'MyCollection'` 的集合。我们调用 `deleteMany()` 函数并传递了一个空对象 `{}` 作为第一个参数，这表示没有任何删除条件，即删除集合中的所有文档。回调函数提供了一个错误参数，用于处理可能发生的错误，如果删除操作成功，会执行 `else` 代码块。

还有另一种方式是使用 `async/await` 语法：

```javascript
// 异步函数来删除所有文档
async function deleteAllDocuments() {
    try {
        const result = await MyModel.deleteMany({});
        console.log('成功删除集合中的所有文档。', result);
    } catch (err) {
        console.error('发生错误:', err);
    }
}

// 调用异步函数
deleteAllDocuments();
```

在这个版本中，我们创建了一个异步函数 `deleteAllDocuments`，在这个函数中，我们使用 `await` 关键字等待 `deleteMany()` 操作完成。这样可以让代码更加干净和易于理解，尤其是在更复杂的逻辑中。如果操作成功，我们会记录输出结果，如果遇到错误，我们会捕获错误并记录。

请注意，在实际场景中删除所有文档是一个具有破坏性的操作，因此在生产环境中应该非常小心地使用，并确保有适当的备份和恢复计划。

`DateTime.remove({}, callback)` The empty object will match all of them.

`.remove()` is deprecated. instead we can use deleteMany

`DateTime.deleteMany({}, callback)`.

In MongoDB, the db.collection.remove() method removes documents from a collection. You can remove all documents from a collection, remove all documents that match a condition, or limit the operation to remove just a single document.

Source: [Mongodb](http://docs.mongodb.org/manual/tutorial/remove-documents/).

If you are using mongo sheel, just do:

    db.Datetime.remove({})
    

In your case, you need:

You didn't show me the delete button, so this button is just an example:

    <a class="button__delete"></a>
    

Change the controller to:

    exports.destroy = function(req, res, next) {
        Datetime.remove({}, function(err) {
                if (err) {
                    console.log(err)
                } else {
                    res.end('success');
                }
            }
        );
    };
    

Insert this ajax delete method in your client js file:

            $(document).ready(function(){
                $('.button__delete').click(function() {
                    var dataId = $(this).attr('data-id');
    
                    if (confirm("are u sure?")) {
                        $.ajax({
                            type: 'DELETE',
                            url: '/',
                            success: function(response) {
                                if (response == 'error') {
                                    console.log('Err!');
                                }
                                else {
                                    alert('Success');
                                    location.reload();
                                }
                            }
                        });
                    } else {
                        alert('Canceled!');
                    }
                });
            });

**MongoDB shell version v4.2.6**  
**Node v14.2.0**

Assuming you have a Tour Model: tourModel.js

    const mongoose = require('mongoose');
    
    const tourSchema = new mongoose.Schema({
      name: {
        type: String,
        required: [true, 'A tour must have a name'],
        unique: true,
        trim: true,
      },
      createdAt: {
        type: Date,
        default: Date.now(),
      },
    });
    const Tour = mongoose.model('Tour', tourSchema);
    
    module.exports = Tour;
    

Now you want to delete all tours at once from your MongoDB, I also providing connection code to connect with the remote cluster. I used deleteMany(), if you do not pass any args to deleteMany(), then it will delete all the documents in Tour collection.

    const mongoose = require('mongoose');
    const Tour = require('./../../models/tourModel');
    const conStr = 'mongodb+srv://lord:<PASSWORD>@cluster0-eeev8.mongodb.net/tour-guide?retryWrites=true&w=majority';
    const DB = conStr.replace('<PASSWORD>','ADUSsaZEKESKZX');
    mongoose.connect(DB, {
        useNewUrlParser: true,
        useCreateIndex: true,
        useFindAndModify: false,
        useUnifiedTopology: true,
      })
      .then((con) => {
        console.log(`DB connection successful ${con.path}`);
      });
    
    const deleteAllData = async () => {
      try {
        await Tour.deleteMany();
        console.log('All Data successfully deleted');
      } catch (err) {
        console.log(err);
      }
    };

`Your_Mongoose_Model.deleteMany({})` can do the job  
  
References:  
[https://mongoosejs.com/docs/api.html#query\_Query-deleteMany](https://mongoosejs.com/docs/api.html#query_Query-deleteMany) [https://www.geeksforgeeks.org/mongoose-deletemany-function/](https://www.geeksforgeeks.org/mongoose-deletemany-function/)

Mongoose 从集合中删除所有文档？

Mongoose 是一个 MongoDB 对象建模工具，设计用于在异步环境中工作。在 Mongoose 中保护密码字段通常需要两个步骤：加密密码和确保在查询时不包括密码字段。

### 加密密码

保护密码字段的第一步是在保存到数据库之前对其进行加密。通常，这是通过使用 bcrypt 或类似的库来实现的。bcrypt 是一个安全的方式，因为它可以对密码进行散列，并且包含了一个盐（salt）来保护密码免受彩虹表攻击。

在 Mongoose 中，你可以使用 pre-save 钩子来在文档保存之前自动加密密码。以下是一个例子：

```javascript
const bcrypt = require('bcrypt');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const userSchema = new Schema({
  username: String,
  password: String,
  // 其他字段...
});

// Pre-save hook 用于加密密码
userSchema.pre('save', async function(next) {
  // 当密码字段被修改时才进行加密
  if (this.isModified('password') || this.isNew) {
    try {
      const salt = await bcrypt.genSalt(10);
      const hash = await bcrypt.hash(this.password, salt);
      this.password = hash;
      next();
    } catch (error) {
      next(error);
    }
  } else {
    next();
  }
});

const User = mongoose.model('User', userSchema);

module.exports = User;
```

### 确保查询时不包括密码字段

即使密码被加密，你通常也不想在查询的响应中包含它。在 Mongoose 中，可以使用查询投影来排除特定字段，或者通过在 schema 中设置 `select: false` 选项来默认排除某些字段。

在 schema 设置中排除密码字段的例子：

```javascript
const userSchema = new Schema({
  username: String,
  password: { type: String, select: false },
  // 其他字段...
});

// ...其余的schema和模型定义
```

当你使用这种方式时，即使你执行了一个普通的查询，像是 `User.find()`，密码字段也不会被返回。如果你在某个特定的查询中需要密码字段，你可以使用 `.select('+password')` 来明确请求它：

```javascript
User.findOne({ username: 'exampleUser' }).select('+password').exec((err, user) => {
  // 现在 `user` 对象将包括密码字段
  // ...
});
```

通过这两个步骤，Mongoose 可以帮助你确保密码字段得到妥善保护并在默认情况下不被查询返回。

You can change the default behavior at the schema definition level using the [`select`](http://mongoosejs.com/docs/api.html#schematype_SchemaType-select) attribute of the field:

    password: { type: String, select: false }
    

Then you can pull it in as needed in `find` and `populate` calls via field selection as `'+password'`. For example:

    Users.findOne({_id: id}).select('+password').exec(...);

.populate('user' , '-password')
    

[http://mongoosejs.com/docs/populate.html](http://mongoosejs.com/docs/populate.html)

JohnnyHKs answer using Schema options is probably the way to go here.

Also note that `query.exclude()` only exists in the 2.x branch.

Edit:

After trying both approaches, I found that the exclude always approach wasn't working for me for some reason using passport-local strategy, don't really know why.

So, this is what I ended up using:

    Blogs.findOne({_id: id})
        .populate("user", "-password -someOtherField -AnotherField")
        .populate("comments.items.user")
        .exec(function(error, result) {
            if(error) handleError(error);
            callback(error, result);
        });
    

There's nothing wrong with the exclude always approach, it just didn't work with passport for some reason, my tests told me that in fact the password was being excluded / included when I wanted. The only problem with the include always approach is that I basically need to go through every call I do to the database and exclude the password which is a lot of work.

* * *

After a couple of great answers I found out there are two ways of doing this, the "always include and exclude sometimes" and the "always exclude and include sometimes"?

An example of both:

**The include always but exclude sometimes** example:

    Users.find().select("-password")
    

or

    Users.find().exclude("password")
    

**The exclude always but include sometimes** example:

    Users.find().select("+password")
    

but you must define in the schema:

    password: { type: String, select: false }

You can achieve that using the schema, for example:

    const UserSchema = new Schema({/* */})
    
    UserSchema.set('toJSON', {
        transform: function(doc, ret, opt) {
            delete ret['password']
            return ret
        }
    })
    
    const User = mongoose.model('User', UserSchema)
    User.findOne() // This should return an object excluding the password field

`User.find().select('-password')` is the right answer. You can not add `select: false` on the Schema since it will not work, if you want to login.

Mongoose 如何保护密码字段，并且在查询时不返回该字段？

在 Mongoose 中，通常我们是通过定义一个 `Schema` 来指定集合中文档的结构，这样既可以确保数据的一致性，也方便开发者理解和操作数据库。然而，在某些情况下，我们可能需要在不定义 schema 的情况下执行操作，Mongoose 提供了这样的灵活性，通过所谓的“不严格”模式或者使用 `mongoose.model` 和 `mongoose.connection` 对象来直接操作。

如果想在不定义 schema 的情况下执行 Mongoose 指令，可以采用以下方法：

### 使用不严格模式的 Schema

即使你定义了一个 Schema，你也可以设置它为“不严格”模式，在这个模式下，Mongoose 不会限制数据的结构，允许存储任何形状的文档。

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 定义一个不严格的 Schema
const anySchema = new Schema({}, { strict: false });
const AnyModel = mongoose.model('AnyCollection', anySchema);

// 现在你可以存储任何形状的文档
const anyDocument = new AnyModel({ any: { thing: 'you want' } });
anyDocument.save();
```

### 使用 `mongoose.model` 和 `mongoose.connection` 对象

另外，你也可以不定义 Schema 而直接使用 `mongoose.model` 和 `mongoose.connection` 对象进行操作。

```javascript
const mongoose = require('mongoose');

// 连接到数据库
mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true });

// 直接获取 Model，注意这里不需要定义 Schema
const AnyModel = mongoose.model('AnyCollection', new mongoose.Schema({}, { strict: false }));

// 通过 Model 创建并保存一个新文档
AnyModel.create({ any: { thing: 'you wish' } }, function (err, result) {
  if (err) throw err;
  // 执行一些其他操作
});

// 直接使用 mongoose.connection 对象操作数据库
const collection = mongoose.connection.collection('anycollection');
collection.insertOne({ anything: 'you want' }, function (err, result) {
  if (err) throw err;
  // 插入成功后的操作
});
```

在这些例子中，我们没有为 `AnyCollection` 定义 Schema，而是利用 Mongoose 提供的机制来执行操作。

不过需要注意的是，虽然这种方法提供了灵活性，但它也有缺点。没有 Schema 的 Mongoose 模型无法利用 Mongoose 提供的很多内置功能，如验证、中间件、静态方法等。此外，无法确保数据的一致性，这可能会导致一些意外的行为和难以调试的问题。所以在开发中应当权衡利弊，并在确实需要灵活性时才考虑不定义 Schema。

I think this is what are you looking for [Mongoose Strict](http://mongoosejs.com/docs/guide.html#strict)

**option: strict**

The strict option, (enabled by default), ensures that values added to our model instance that were not specified in our schema do not get saved to the db.

**Note: Do not set to false unless you have good reason.**

        var thingSchema = new Schema({..}, { strict: false });
        var Thing = mongoose.model('Thing', thingSchema);
        var thing = new Thing({ iAmNotInTheSchema: true });
        thing.save() // iAmNotInTheSchema is now saved to the db!!

Actually "Mixed" (`Schema.Types.Mixed`) mode appears to do exactly that in Mongoose...

it accepts a **schema-less**, **freeform JS object** - so whatever you can throw at it. It seems you have to trigger saves on that object manually afterwards, but it seems like a fair tradeoff.

> Mixed
> -----
> 
> An "anything goes" SchemaType, its flexibility comes at a trade-off of it being harder to maintain. Mixed is available either through `Schema.Types.Mixed` or by passing an empty object literal. The following are equivalent:
> 
>     var Any = new Schema({ any: {} });
>     var Any = new Schema({ any: Schema.Types.Mixed });
>     
> 
> Since it is a schema-less type, you can change the value to anything else you like, but Mongoose loses the ability to auto detect and save those changes. To "tell" Mongoose that the value of a Mixed type has changed, call the `.markModified(path)` method of the document passing the path to the Mixed type you just changed.
> 
>     person.anything = { x: [3, 4, { y: "changed" }] };
>     person.markModified('anything');
>     person.save(); // anything will now get saved
>     

*   [Mongoose Schema Types](http://mongoosejs.com/docs/schematypes.html#mixed)

Hey Chris, take a look at [Mongous](https://github.com/amark/mongous). I was having the same issue with mongoose, as my Schemas change extremely frequently right now in development. Mongous allowed me to have the simplicity of Mongoose, while being able to loosely define and change my 'schemas'. I chose to simply build out standard JavaScript objects and store them in the database like so

    function User(user){
      this.name = user.name
    , this.age = user.age
    }
    
    app.post('save/user', function(req,res,next){
      var u = new User(req.body)
      db('mydb.users').save(u)
      res.send(200)
      // that's it! You've saved a user
    });
    

Far more simple than Mongoose, although I do believe you miss out on some cool middleware stuff like "pre". I didn't need any of that though. Hope this helps!!!

Here is the details description: \[[https://www.meanstack.site/2020/01/save-data-to-mongodb-without-defining.html\]\[1\]](https://www.meanstack.site/2020/01/save-data-to-mongodb-without-defining.html][1])

        const express = require('express')()
        const mongoose = require('mongoose')
        const bodyParser = require('body-parser')
        const Schema = mongoose.Schema
    
        express.post('/', async (req, res) => {
            // strict false will allow you to save document which is coming from the req.body
            const testCollectionSchema = new Schema({}, { strict: false })
            const TestCollection = mongoose.model('test_collection', testCollectionSchema)
            let body = req.body
            const testCollectionData = new TestCollection(body)
            await testCollectionData.save()
            return res.send({
                "msg": "Data Saved Successfully"
            })
        })
    
    
      [1]: https://www.meanstack.site/2020/01/save-data-to-mongodb-without-defining.html

You can also use `mongoose.connection.collection`

    import mongoose from 'mongoose';
    
    const collection = mongoose.connection.collection('user')
    
    // use it like a mongodb collection
    await collection.updateOne({ name: "name" }, { $set: { name: "new_name" } })
    

See [mongoose documentation](https://mongoosejs.com/docs/api/connection.html#Connection.prototype.collection())

Mongoose 如何在不定义 schema 的情况下执行 mongoose 指令？

在 Mongoose 中，限制查询返回的数据长度通常是通过两个方法来实现的：`limit()` 和 `skip()`。这两种方法对应于 MongoDB 的分页功能，`limit()` 用于指定返回结果的最大数量，而 `skip()` 用于指定跳过记录的数量。

例如，如果你想查询某个集合并只获取前10条记录，可以如下使用 `limit()` 方法：

```javascript
const query = Model.find();
query.limit(10);
query.exec((err, documents) => {
  // 处理查询结果或错误
});
```

如果你还需要实现分页功能，比如跳过前20条记录，只获取接下来的10条记录，可以组合使用 `skip()` 和 `limit()` 方法：

```javascript
const query = Model.find();
query.skip(20); // 跳过前20条
query.limit(10); // 限制返回的记录数为10
query.exec((err, documents) => {
  // 处理查询结果或错误
});
```

此外，Mongoose 还允许你在一条链式查询中直接调用 `limit()` 和 `skip()` 方法：

```javascript
Model.find()
  .skip(20) // 跳过前20条
  .limit(10) // 限制返回的记录数为10
  .exec((err, documents) => {
    // 处理查询结果或错误
  });
```

以上就是在 Mongoose 中限制查询返回数据长度的基本方法。在实际应用中，根据需求你可能还需要结合排序（`sort()` 方法）和投影（选择性返回某些字段，使用 `select()` 方法）来进一步控制查询结果。

Mongoose 如何限制一个查询返回的数据长度？

当您使用Mongoose查询一个预先存在的集合时，您首先需要定义一个与该集合匹配的模型。这涉及到两个主要步骤：定义您的模式（Schema），然后根据该模式创建一个模型。以下是具体的步骤：

1. **定义模式（Schema）**：模式是一个对象，它定义了存储在MongoDB集合中的文档的结构和规则。这包括每个字段的类型、是否必填、默认值、验证等。

    ```javascript
    const mongoose = require('mongoose');
    const { Schema } = mongoose;

    const myExistingCollectionSchema = new Schema({
      // 在这里定义字段和它们的类型
      name: String,
      age: Number,
      // 更多字段...
    });
    ```

2. **创建模型（Model）**：模型是一个与定义的模式相对应的构造函数，你可以使用这个构造函数与数据库中的集合进行交云。

    ```javascript
    const MyModel = mongoose.model('MyExistingCollection', myExistingCollectionSchema);
    ```

    请注意，`mongoose.model`的第一个参数是你希望Mongoose连接到的集合名称。Mongoose默认会将模型名字转为小写并且复数形式来查找集合。如果您的集合名不符合这个转换规则，您需要在第三个参数中明确指定集合的名称：

    ```javascript
    const MyModel = mongoose.model('MyExistingCollection', myExistingCollectionSchema, 'custom_collection_name');
    ```

3. **执行查询**：一旦你有了一个模型，你就可以使用它来查询集合。Mongoose提供了多种方法来检索和操作数据，如 `find`, `findOne`, `findById` 等。

    ```javascript
    // 查询所有文档
    MyModel.find({}, function(err, results) {
      if (err) throw err;
      // 处理查询结果
      console.log(results);
    });

    // 根据条件查询单个文档
    MyModel.findOne({ age: { $gte: 18 } }, function(err, result) {
      if (err) throw err;
      // 处理查询结果
      console.log(result);
    });

    // 根据ID查询单个文档
    MyModel.findById('某个文档的ID', function(err, result) {
      if (err) throw err;
      // 处理查询结果
      console.log(result);
    });
    ```

**示例**：

假设我们有一个名为 `users` 的集合，其中包含姓名（name）、年龄（age）等信息。下面的示例代码展示了如何定义对应的模型并查询所有年龄大于等于18的用户。

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 连接到数据库
mongoose.connect('mongodb://localhost/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true });

// 定义模式
const userSchema = new Schema({
  name: String,
  age: Number,
});

// 创建模型，假设集合名字正好是 `users` 的复数小写形式
const User = mongoose.model('User', userSchema);

// 执行查询
User.find({ age: { $gte: 18 } }, (err, users) => {
  if (err) {
    console.error(err);
  } else {
    console.log('成年用户:', users);
  }
});
```

这样就可以查询到预先存在的 `users` 集合中所有年龄大于等于18的文档了。

Mongoose added the ability to specify the collection name under the schema, or as the third argument when declaring the model. Otherwise it will use the pluralized version given by the name you map to the model.

Try something like the following, either schema-mapped:

    new Schema({ url: String, text: String, id: Number}, 
               { collection : 'question' });   // collection name
    

or model mapped:

    mongoose.model('Question', 
                   new Schema({ url: String, text: String, id: Number}), 
                   'question');     // collection name

Here's an abstraction of Will Nathan's answer if anyone just wants an easy copy-paste add-in function:

    function find (name, query, cb) {
        mongoose.connection.db.collection(name, function (err, collection) {
           collection.find(query).toArray(cb);
       });
    }
    

simply do `find(collection_name, query, callback);` to be given the result.

for example, if I have a document { a : 1 } in a collection 'foo' and I want to list its properties, I do this:

    find('foo', {a : 1}, function (err, docs) {
                console.dir(docs);
            });
    //output: [ { _id: 4e22118fb83406f66a159da5, a: 1 } ]

You can do something like this, than you you'll access the native mongodb functions inside mongoose:

    var mongoose = require("mongoose");
    mongoose.connect('mongodb://localhost/local');
    
    var connection = mongoose.connection;
    
    connection.on('error', console.error.bind(console, 'connection error:'));
    connection.once('open', function () {
    
        connection.db.collection("YourCollectionName", function(err, collection){
            collection.find({}).toArray(function(err, data){
                console.log(data); // it will print your collection data
            })
        });
    
    });
    

* * *

**Update 2022**

If you get an `MongoInvalidArgumentError: The callback form of this helper has been removed.` error message, here's the new syntax using `async/await`:

    const mongoose = require("mongoose");
    mongoose.connect('mongodb://localhost/productsDB');
    
    const connection = mongoose.connection;
    
    connection.on('error', console.error.bind(console, 'connection error:'));
    connection.once('open', async function () {
    
      const collection  = connection.db.collection("Products");
      collection.find({}).toArray(function(err, data){
          console.log(data); // it will print your collection data
      });
    
    });

I had the same problem and was able to run a schema-less query using an existing Mongoose connection with the code below. I've added a simple constraint 'a=b' to show where you would add such a constraint:

    var action = function (err, collection) {
        // Locate all the entries using find
        collection.find({'a':'b'}).toArray(function(err, results) {
            /* whatever you want to do with the results in node such as the following
                 res.render('home', {
                     'title': 'MyTitle',
                     'data': results
                 });
            */
        });
    };
    
    mongoose.connection.db.collection('question', action);

Are you sure you've connected to the db? (I ask because I don't see a port specified)

try:

    mongoose.connection.on("open", function(){
      console.log("mongodb is connected!!");
    });
    

Also, you can do a "show collections" in mongo shell to see the collections within your db - maybe try adding a record via mongoose and see where it ends up?

From the look of your connection string, you should see the record in the "test" db.

Hope it helps!

Mongoose 如何查询预先存在的集合？

在Mongoose中，如果您想获取所有model的总数，您通常需要对每个model分别执行一个count操作，并将结果累加。下面给出一个如何在Mongoose中实现这一过程的示例：

假设您有多个model，比如`User`, `Post`, 和 `Comment`，您可以如下进行：

```javascript
const mongoose = require('mongoose');

// 假设您已经定义并连接了models
const User = mongoose.model('User');
const Post = mongoose.model('Post');
const Comment = mongoose.model('Comment');

async function getTotalCountOfModels() {
  try {
    // 分别获取每个model的数量
    const userCount = await User.countDocuments().exec();
    const postCount = await Post.countDocuments().exec();
    const commentCount = await Comment.countDocuments().exec();

    // 将所有model的数量累加
    const totalCount = userCount + postCount + commentCount;
    
    console.log(`总数为: ${totalCount}`);
    return totalCount;
  } catch (error) {
    console.error('获取model总数时发生错误', error);
    throw error;
  }
}

// 调用函数
getTotalCountOfModels()
  .then(total => console.log('总数量为:', total))
  .catch(err => console.error(err));
```

在这个例子中，`countDocuments()` 方法被用来计算每个model中document的数量。我们通过`async/await`进行异步操作，并使用`try/catch`来处理可能出现的错误。

这是一个基础的例子，实际应用中可能会涉及更复杂的逻辑，比如过滤条件、关联查询等。此外，如果模型非常多，可能需要一个更自动化的方法来循环处理所有模型，而不是手动一个一个地调用。

The reason your code doesn't work is because the count function is asynchronous, it doesn't synchronously return a value.

Here's an example of usage:

    userModel.count({}, function( err, count){
        console.log( "Number of users:", count );
    })

The code below works. Note the use of [countDocuments](https://mongoosejs.com/docs/api.html#model_Model.countDocuments).

     var mongoose = require('mongoose');
     var db = mongoose.connect('mongodb://localhost/myApp');
     var userSchema = new mongoose.Schema({name:String,password:String});
     var userModel =db.model('userlists',userSchema);
     var anand = new userModel({ name: 'anand', password: 'abcd'});
     anand.save(function (err, docs) {
       if (err) {
           console.log('Error');
       } else {
           userModel.countDocuments({name: 'anand'}, function(err, c) {
               console.log('Count is ' + c);
          });
       }
     });

You should give an object as argument

    userModel.countDocuments({name: "sam"});
    

or

    userModel.countDocuments({name: "sam"}).exec(); //if you are using promise
    

or

    userModel.countDocuments({}); // if you want to get all counts irrespective of the fields
    

For the older versions of mongoose, use

    userModel.count({name: "sam"});

The collection.count is deprecated, and will be removed in a future version. Use collection.**countDocuments** or collection.**estimatedDocumentCount** instead.

    userModel.countDocuments(query).exec((err, count) => {
        if (err) {
            res.send(err);
            return;
        }
    
        res.json({ count: count });
    });

Background for the solution
===========================

As stated in the mongoose documentation and in the answer by Benjamin, the method [`Model.count()`](https://mongoosejs.com/docs/api.html#model_Model.count) is deprecated. Instead of using `count()`, the alternatives are the following:

**[`Model.countDocuments(filterObject, callback)`](https://mongoosejs.com/docs/api.html#model_Model.countDocuments)**

Counts how many documents match the filter in a collection. Passing an empty object {} as filter executes a full collection scan. If the collection is large, the following method might be used.

**[`Model.estimatedDocumentCount()`](https://mongoosejs.com/docs/api.html#model_Model.estimatedDocumentCount)**

This model method estimates the number of documents in the MongoDB collection. This method is faster than the previous `countDocuments()`, because it uses collection metadata instead of going through the entire collection. However, as the method name suggests, and depending on db configuration, the result is an estimate as the metadata might not reflect the actual count of documents in a collection at the method execution moment.

Both methods return a mongoose query object, which can be executed in one of the following two ways. Use `.exec()` if you want to execute a query at a later time.

The solution
============

Option 1: Pass a callback function
----------------------------------

For example, count all documents in a collection using `.countDocuments()`:

    someModel.countDocuments({}, function(err, docCount) {
        if (err) { return handleError(err) } //handle possible errors
        console.log(docCount)
        //and do some other fancy stuff
    })
    

Or, count all documents in a collection having a certain name using `.countDocuments()`:

    someModel.countDocuments({ name: 'Snow' }, function(err, docCount) {
        //see other example
    }
    

Option 2: Use `.then()`
-----------------------

A mongoose query has `.then()` so it’s “thenable”. This is for a convenience and query itself is not a promise.

For example, count all documents in a collection using `.estimatedDocumentCount()`:

    someModel
        .estimatedDocumentCount()
        .then(docCount => {
            console.log(docCount)
            //and do one super neat trick
        })
        .catch(err => {
            //handle possible errors
        })
    

Option 3: Use async/await
-------------------------

When using async/await approach, the [recommended](https://mongoosejs.com/docs/promises.html#should-you-use-exec-with-await?) way is to use it with `.exec()` as it provides better stack traces.

    const docCount = await someModel.countDocuments({}).exec();
    

_Learning by stackoverflowing,_

Mongoose 如何获取所有 model 的总数？

在 Mongoose 中，`ObjectId` 是 MongoDB 的一种数据类型，用于唯一标识文档。Mongoose 使用 MongoDB 下层的 `bson` 库来生成 `ObjectId`。

当你在 Mongoose 模型中定义了一个字段类型为 `ObjectId`，比如在用户模型的定义中：

```js
const mongoose = require('mongoose');
const { Schema } = mongoose;

const userSchema = new Schema({
  name: String,
  // 定义 ObjectId 类型字段
  _id: Schema.Types.ObjectId 
});

const User = mongoose.model('User', userSchema);
```

在你创建一个新文档并保存到数据库中时，Mongoose 会自动为这个 `_id` 字段生成一个新的 `ObjectId`。例如：

```js
const newUser = new User({
  name: 'John Doe'
});

newUser.save((err, savedUser) => {
  if (err) throw err;
  // savedUser._id 将会是一个自动生成的 ObjectId
  console.log(savedUser._id);
});
```

如果你没有显式地在你的模型定义中声明 `_id` 字段，Mongoose 会默认为你的每个文档添加一个 `_id` 字段，并自动生成一个 `ObjectId`。

`ObjectId` 是一个 12 字节的值，通常由以下几部分构成：

1. 4字节的时间戳，表示 ObjectId 的创建时间。
2. 5字节的随机值，为了确保在同一时间生成的 ObjectId 是唯一的。
3. 3字节的增量计数器，从随机值开始。

这种结构确保即使在大量操作下，生成的 ObjectId 也是唯一且按时间顺序排列的。

在某些情况下，你可能需要手动生成一个 `ObjectId`。你可以使用 Mongoose 提供的 `Types` 对象来做到这一点：

```js
const { Types } = require('mongoose');
const objectId = new Types.ObjectId();
```

现在 `objectId` 变量就包含了一个新生成的 `ObjectId` 实例，可以用在任何需要 ObjectId 的地方。

You can find the `ObjectId` constructor on `require('mongoose').Types`. Here is an example:

    var mongoose = require('mongoose');
    var id = mongoose.Types.ObjectId();
    

`id` is a newly generated `ObjectId`.

* * *

**Note**: As [Joshua Sherman](https://stackoverflow.com/questions/17899750/how-can-i-generate-an-objectid-with-mongoose/17899751?noredirect=1#comment122158950_17899751) points out, with Mongoose 6 you must prefix the call with `new`:

    var id = new mongoose.Types.ObjectId();
    

* * *

You can read more about the `Types` object at [Mongoose#Types documentation](https://mongoosejs.com/docs/schematypes.html#objectids).

You can create a new MongoDB `ObjectId` like this using mongoose:

    var mongoose = require('mongoose');
    var newId = new mongoose.mongo.ObjectId('56cb91bdc3464f14678934ca');
    // or leave the id string blank to generate an id with a new hex identifier
    var newId2 = new mongoose.mongo.ObjectId();

I needed to generate mongodb ids on client side.

After digging into the mongodb source code i found they generate ObjectIDs using npm `bson` lib.

If ever you need only to generate an ObjectID without installing the whole mongodb / mongoose package, you can import the lighter `bson` library :

    const bson = require('bson');
    new bson.ObjectId(); // 5cabe64dcf0d4447fa60f5e2
    

Note: There is also an npm project named `bson-objectid` being even lighter

With ES6 syntax

    import mongoose from "mongoose";
    
    // Generate a new new ObjectId
    const newId2 = new mongoose.Types.ObjectId();
    // Convert string to ObjectId
    const newId = new mongoose.Types.ObjectId('56cb91bdc3464f14678934ca');

The import is mongo from mongoose, the node-mongodb-native driver. If you open the package you can verify !

    import { mongo } from 'mongoose'
    const newId = new mongo.ObjectId()

Mongoose 如何生成 objectID 类型数据？

在使用Mongoose进行分页搜索时，通常会涉及到两个关键概念：`limit` 和 `skip`。这两个参数可以在MongoDB的查询中使用，以实现分页的效果。`limit` 用于限制查询结果的数量，而 `skip` 用于跳过指定数量的文档。

以下是如何使用Mongoose进行分页的步骤：

1. **确定每页的大小（即limit）：** 这是你想要每页显示的记录数。
2. **计算跳过的文档数（即skip）：** 这是根据当前的页码计算出需要跳过的记录数。例如，如果你每页显示10条记录，那么在第二页你需要跳过的记录数为 `10 * (当前页码 - 1)`。

### 示例代码

这是一个简单的例子，展示了如何使用Mongoose来实现分页搜索：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 假设我们有一个用户模型
const UserSchema = new Schema({
  name: String,
  age: Number,
  // 更多字段...
});

const User = mongoose.model('User', UserSchema);

// 分页函数
async function findUsersWithPagination(page, limit) {
  try {
    // 计算需要跳过的文档数
    const skip = (page - 1) * limit;

    // 获取分页的数据
    const users = await User.find()
      .skip(skip)   // 跳过前面的文档
      .limit(limit) // 限制返回的文档数
      .exec();      // 执行查询

    // 获取总的文档数以计算总页数
    const count = await User.countDocuments();

    return {
      total: count,           // 总文档数
      perPage: limit,         // 每页文档数
      currentPage: page,      // 当前页码
      totalPages: Math.ceil(count / limit), // 总页数
      data: users             // 当前页的数据
    };
  } catch (error) {
    throw error;
  }
}

// 使用分页函数，比如获取第2页的数据，每页5条记录
findUsersWithPagination(2, 5).then(paginatedResults => {
  console.log(paginatedResults);
}).catch(err => {
  console.error(err);
});
```

在这个示例中，`findUsersWithPagination` 函数接收 `page` 和 `limit` 作为参数，然后使用这些参数来调整查询。它先计算需要跳过的记录数，然后应用 `skip` 和 `limit` 方法到查询中。最后，它还计算出总的文档数，以便可以返回有关分页的详细信息。

请注意，在实际的应用程序中，你可能还需要考虑排序问题，以确保文档以一致的顺序返回，这通常可以通过在 `find` 查询中使用 `.sort()` 方法来实现。

此外，如果你正在处理大量的数据，频繁地使用 `skip` 可能会导致性能问题，因为 `skip` 会导致数据库遍历过多的文档。在这种情况下，你可能需要考虑使用游标或者其他分页策略。

I'm am very disappointed by the accepted answers in this question. This will not scale. If you read the fine print on cursor.skip( ):

> The cursor.skip() method is often expensive because it requires the server to walk from the beginning of the collection or index to get the offset or skip position before beginning to return result. As offset (e.g. pageNumber above) increases, cursor.skip() will become slower and more CPU intensive. With larger collections, cursor.skip() may become IO bound.

To achieve pagination in a scaleable way combine a limit( ) along with at least one filter criterion, a createdOn date suits many purposes.

    MyModel.find( { createdOn: { $lte: request.createdOnBefore } } )
    .limit( 10 )
    .sort( '-createdOn' )

After taking a closer look at the Mongoose API with the information provided by Rodolphe, I figured out this solution:

    MyModel.find(query, fields, { skip: 10, limit: 5 }, function(err, results) { ... });

Pagination using mongoose, express and jade - [Here's a link to my blog with more detail](http://madhums.me/2012/08/20/pagination-using-mongoose-express-and-jade/)

    var perPage = 10
      , page = Math.max(0, req.params.page)
    
    Event.find()
        .select('name')
        .limit(perPage)
        .skip(perPage * page)
        .sort({
            name: 'asc'
        })
        .exec(function(err, events) {
            Event.count().exec(function(err, count) {
                res.render('events', {
                    events: events,
                    page: page,
                    pages: count / perPage
                })
            })
        })

You can chain just like that:

    var query = Model.find().sort('mykey', 1).skip(2).limit(5)
    

Execute the query using `exec`

    query.exec(callback);

In this case, you can add the query `page` and/ or `limit` to your URL as a query string.

For example:  
`?page=0&limit=25 // this would be added onto your URL: http:localhost:5000?page=0&limit=25`

Since it would be a `String` we need to convert it to a `Number` for our calculations. Let's do it using the `parseInt` method and let's also provide some default values.

    const pageOptions = {
        page: parseInt(req.query.page, 10) || 0,
        limit: parseInt(req.query.limit, 10) || 10
    }
    
    sexyModel.find()
        .skip(pageOptions.page * pageOptions.limit)
        .limit(pageOptions.limit)
        .exec(function (err, doc) {
            if(err) { res.status(500).json(err); return; };
            res.status(200).json(doc);
        });
    

**BTW** Pagination starts with `0`

Mongoose 如何进行分页搜索？

在Mongoose中，排序可以通过在查询后使用 `.sort()` 方法来实现。该方法接受一个参数，该参数可以是字符串或对象，用于指定根据哪些字段进行排序以及排序的方向（升序或降序）。在MongoDB中，升序使用 `1` 表示，而降序使用 `-1` 表示。

以下是如何使用 `.sort()` 方法的一些例子：

### 使用字符串进行排序

如果您只需要根据一个字段进行排序，可以直接传递一个字段名，前面带有 `-` 表示降序，不带任何符号表示升序。

```javascript
// 升序排序
MyModel.find().sort('field').exec((err, docs) => {
  // 处理结果或错误
});

// 降序排序
MyModel.find().sort('-field').exec((err, docs) => {
  // 处理结果或错误
});
```

### 使用对象进行排序

如果您要根据多个字段进行排序，可以传递一个对象，键是字段名，值是 `1` 或 `-1` 来分别表示升序或降序。

```javascript
// 根据多个字段进行排序
MyModel.find().sort({ field1: 1, field2: -1 }).exec((err, docs) => {
  // 处理结果或错误
});
```

### 示例

假设您有一个用户模型 `User`，并且您想根据年龄进行升序排序，然后根据用户名进行降序排序，您可以这样做：

```javascript
User.find().sort({ age: 1, username: -1 }).exec((err, users) => {
  if (err) {
    console.error(err);
  } else {
    console.log(users); // 这将输出根据年龄升序、用户名降序排序的用户数组
  }
});
```

通过这种方式，您可以轻松地根据一个或多个字段对查询结果进行排序，这在处理大量数据时尤其有用，可以帮助您更快地定位到感兴趣的记录。

In Mongoose, a sort can be done in any of the following ways:

        Post.find({}).sort('test').exec(function(err, docs) { ... });
        Post.find({}).sort([['date', -1]]).exec(function(err, docs) { ... });
        Post.find({}).sort({test: 1}).exec(function(err, docs) { ... });
        Post.find({}, null, {sort: {date: 1}}, function(err, docs) { ... });

This is how I got sort to work in mongoose 2.3.0 :)

    // Find First 10 News Items
    News.find({
        deal_id:deal._id // Search Filters
    },
    ['type','date_added'], // Columns to Return
    {
        skip:0, // Starting Row
        limit:10, // Ending Row
        sort:{
            date_added: -1 //Sort by Date Added DESC
        }
    },
    function(err,allNews){
        socket.emit('news-load', allNews); // Do something with the array of 10 objects
    })

As of Mongoose 3.8.x:

    model.find({ ... }).sort({ field : criteria}).exec(function(err, model){ ... });
    

**Where:**

`criteria` can be `asc`, `desc`, `ascending`, `descending`, `1`, or `-1`

**Note: Use quotation marks or double quote**

use `"asc"`, `"desc"`, `"ascending"`, `"descending"`, `1`, or `-1`

UPDATE:

    Post.find().sort({'updatedAt': -1}).all((posts) => {
      // do something with the array of posts
    });
    

* * *

Try:

    Post.find().sort([['updatedAt', 'descending']]).all((posts) => {
      // do something with the array of posts
    });

**Mongoose v5.x.x**

sort by ascending order

    Post.find({}).sort('field').exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'asc' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'ascending' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 1 }).exec(function(err, docs) { ... });
    
    Post.find({}, null, {sort: { field : 'asc' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : 'ascending' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : 1 }}), function(err, docs) { ... });
    

sort by descending order

    Post.find({}).sort('-field').exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'desc' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: 'descending' }).exec(function(err, docs) { ... });
    Post.find({}).sort({ field: -1 }).exec(function(err, docs) { ... });
    
    
    Post.find({}, null, {sort: { field : 'desc' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : 'descending' }}), function(err, docs) { ... });
    Post.find({}, null, {sort: { field : -1 }}), function(err, docs) { ... });
    

For Details: [https://mongoosejs.com/docs/api.html#query\_Query-sort](https://mongoosejs.com/docs/api.html#query_Query-sort)

Mongoose 中搜索时如何进行排序？

在Mongoose中，更新文档（通常在 MongoDB 中称为记录）可以通过几种不同的方法来实现。如果你提到的 "upstart" 文档是指需要更新的文档，那么我将展示几种在 Mongoose 中更新文档的常用方法，并提供示例。

### 使用 `save()` 方法更新文档

如果你已经查询到了一个 Mongoose 文档实例，你可以直接修改它的属性，然后调用 `.save()` 方法来更新它。

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

const UserSchema = new Schema({ name: String, age: Number });
const User = mongoose.model('User', UserSchema);

async function updateUser(userId) {
  try {
    // 查询文档
    const user = await User.findById(userId);
    if (user) {
      // 修改文档的属性
      user.name = '新的名字';
      user.age = 30;

      // 保存文档
      await user.save();
      console.log('Document updated successfully');
    } else {
      console.log('Document not found');
    }
  } catch (error) {
    console.error('Error updating document:', error);
  }
}
```

### 使用 `updateOne()` 或 `updateMany()` 方法

如果你不需要先检索整个文档，你可以直接使用 `updateOne()` 或 `updateMany()` 方法来更新一个或多个文档。

```javascript
async function updateUserName(userId, newName) {
  try {
    // 更新单个文档
    const result = await User.updateOne({ _id: userId }, { $set: { name: newName } });
    if (result.matchedCount === 1) {
      console.log('Document updated successfully');
    } else {
      console.log('No documents matched the query. Document not updated');
    }
  } catch (error) {
    console.error('Error updating document:', error);
  }
}
```

### 使用 `findOneAndUpdate()` 方法

如果你想在更新文档的同时检索更新后的文档，你可以使用 `findOneAndUpdate()` 方法。

```javascript
async function findAndUpdateUser(userId, newName) {
  try {
    const options = { new: true }; // 返回更新后的文档
    const updatedUser = await User.findOneAndUpdate({ _id: userId }, { $set: { name: newName } }, options);
    if (updatedUser) {
      console.log('Document updated and retrieved successfully:', updatedUser);
    } else {
      console.log('Document not found');
    }
  } catch (error) {
    console.error('Error finding and updating document:', error);
  }
}
```

在这些示例中，我们使用了 MongoDB 的更新操作符 `$set` 来指定我们希望更新的字段。同时还可以使用其他更新操作符来执行更复杂的更新操作。根据你的需求，你可以选择最适合你的更新策略。

注意：确保在执行更新操作时遵循最佳实践，比如验证输入、处理错误等。

Mongoose now supports this natively with [findOneAndUpdate](https://mongoosejs.com/docs/api.html#model_Model-findOneAndUpdate) (calls MongoDB [findAndModify](https://www.mongodb.com/docs/manual/reference/method/db.collection.findAndModify/)).

The upsert = true option creates the object if it doesn't exist. _defaults to false_.

    var query = {'username': req.user.username};
    req.newData.username = req.user.username;
    
    MyModel.findOneAndUpdate(query, req.newData, {upsert: true}, function(err, doc) {
        if (err) return res.send(500, {error: err});
        return res.send('Succesfully saved.');
    });
    

* * *

In older versions Mongoose does not support these hooks with this method:

*   defaults
*   setters
*   validators
*   middleware

I just burned a solid 3 hours trying to solve the same problem. Specifically, I wanted to "replace" the entire document if it exists, or insert it otherwise. Here's the solution:

    var contact = new Contact({
      phone: request.phone,
      status: request.status
    });
    
    // Convert the Model instance to a simple object using Model's 'toObject' function
    // to prevent weirdness like infinite looping...
    var upsertData = contact.toObject();
    
    // Delete the _id property, otherwise Mongo will return a "Mod on _id not allowed" error
    delete upsertData._id;
    
    // Do the upsert, which works like this: If no Contact document exists with 
    // _id = contact.id, then create a new doc using upsertData.
    // Otherwise, update the existing doc with upsertData
    Contact.update({_id: contact.id}, upsertData, {upsert: true}, function(err{...});
    

I created [an issue on the Mongoose project page](https://github.com/LearnBoost/mongoose/issues/571) requesting that info about this be added to the docs.

You were close with

    Contact.update({phone:request.phone}, contact, {upsert: true}, function(err){...})
    

but your second parameter should be an object with a modification operator for example

    Contact.update({phone:request.phone}, {$set: { phone: request.phone }}, {upsert: true}, function(err){...})

Well, I waited long enough and no answer. Finally gave up the whole update/upsert approach and went with:

    ContactSchema.findOne({phone: request.phone}, function(err, contact) {
        if(!err) {
            if(!contact) {
                contact = new ContactSchema();
                contact.phone = request.phone;
            }
            contact.status = request.status;
            contact.save(function(err) {
                if(!err) {
                    console.log("contact " + contact.phone + " created at " + contact.createdAt + " updated at " + contact.updatedAt);
                }
                else {
                    console.log("Error: could not save contact " + contact.phone);
                }
            });
        }
    });
    

Does it work? Yep. Am I happy with this? Probably not. 2 DB calls instead of one.  
Hopefully a future Mongoose implementation would come up with a `Model.upsert` function.

I'm the maintainer of Mongoose. The more modern way to upsert a doc is to use the [`Model.updateOne()` function](https://mongoosejs.com/docs/api/model.html#model_Model.updateOne).

    await Contact.updateOne({
        phone: request.phone
    }, { status: request.status }, { upsert: true });
    

If you need the upserted doc, you can use [`Model.findOneAndUpdate()`](https://mongoosejs.com/docs/tutorials/findoneandupdate.html)

    const doc = await Contact.findOneAndUpdate({
        phone: request.phone
    }, { status: request.status }, { upsert: true, useFindAndModify: false });
    

The key takeaway is that you need to put the unique properties in the `filter` parameter to `updateOne()` or `findOneAndUpdate()`, and the other properties in the `update` parameter.

Here's a tutorial on [upserting documents with Mongoose](https://masteringjs.io/tutorials/mongoose/upsert).

Mongoose 如何更新一条数据/文档？

在 MongoDB 中，您可以使用 `$slice` 操作符来查询数组的最后一个元素。 `$slice` 可以与 `.find()` 或 `.findOne()` 方法一起使用来指定您想从数组中选择的元素的数量和位置。

如果您只想查询数组的最后一个元素，可以将 `$slice` 设置为 `-1`。以下是一个查询示例，它演示了如何选取数组字段 `arrayField` 中的最后一个元素：

```javascript
db.collection.find({}, { arrayField: { $slice: -1 } })
```

在这个例子中：

- `db.collection` 表示 MongoDB 中的集合。
- `{}` 是查询条件（空，意味着选择所有文档）。
- `{ arrayField: { $slice: -1 } }` 是投影，它指定只返回 `arrayField` 的最后一个元素。

如果您有一个具体的查询条件，并且只想针对满足该条件的文档获取数组的最后一个元素，您可以像这样组合它：

```javascript
db.collection.find({ someField: someValue }, { arrayField: { $slice: -1 } })
```

在这个例子中：

- `{ someField: someValue }` 是查询条件，用以选择具有特定 `someField` 字段值为 `someValue` 的文档。
- `{ arrayField: { $slice: -1 } }` 同样是投影，用来只选择 `arrayField` 中的最后一个元素。

请注意，`$slice` 不仅可以用来获取最后一个元素，还可以用来获取数组的子集，例如获取最后三个元素（`{ $slice: -3 }`）或跳过数组的前两个元素后取两个元素（`{ $slice: [2, 2] }`）。好的，继续补充 `$slice` 的应用，我们可以进一步讨论如何获取数组中的特定范围的元素。这在处理分页或者仅获取感兴趣的部分数据时非常有用。

比如，如果我们想要获取数组中从第二个元素开始的三个元素，我们可以设置 `$slice` 如下：

```javascript
db.collection.find({}, { arrayField: { $slice: [1, 3] } })
```

在这里：

- `[1, 3]` 表示从索引为 `1` （数组的第二个元素）开始获取，然后向后数 `3` 个元素。

此外，MongoDB 也允许你结合使用 `$elemMatch` 查询操作符和 `$slice` 来选择匹配特定条件的数组元素的子集。例如，如果你想要找到含有特定元素的文档，并且仅返回这个元素，可以这样做：

```javascript
db.collection.find({ arrayField: { $elemMatch: { key: value } } }, { 'arrayField.$': 1 })
```

在这个例子中：

- `{ arrayField: { $elemMatch: { key: value } } }` 是查询条件，它会匹配那些在数组 `arrayField` 中至少有一个元素含有键 `key` 并且值为 `value` 的文档。
- `{'arrayField.$': 1}` 是投影，它指定只返回匹配 `$elemMatch` 条件的第一个元素。

结合 `$slice` 和 `$elemMatch` 的高级用法可能会更复杂，但上述的用例展示了如何查询数组的特定部分，包括最后一个元素的常见做法。在实际的应用中，这些技术可以帮助您有效地查询和处理存储在 MongoDB 数组中的数据。

在 3.2 中这是可能的。第一个项目让 myField 只包含最后一个元素，然后在 myField 上进行匹配。

    db.collection.aggregate([
       { $project: { id: 1, myField: { $slice: [ "$myField", -1 ] } } },
       { $match: { myField: "myValue" } }
    ]);

您可以使用[$expr](https://docs.mongodb.com/manual/reference/operator/query/expr/)（3.6 mongo 版本运算符）在常规查询中使用聚合函数。

比较[`query operators`](https://docs.mongodb.com/manual/reference/operator/query/)与[`aggregation comparison operators`](https://docs.mongodb.com/manual/reference/operator/aggregation-comparison/)\_

对于标量数组

    db.col.find({$expr: {$gt: [{$arrayElemAt: ["$array", -1]}, value]}})
    

对于嵌入式数组 - 使用[`$arrayElemAt`](https://docs.mongodb.com/manual/reference/operator/aggregation/arrayElemAt/)带有点表示法的表达式来投影最后一个元素。

    db.col.find({$expr: {$gt: [{"$arrayElemAt": ["$array.field", -1]}, value]}})
    

弹簧`@Query`代码

    @Query("{$expr:{$gt:[{$arrayElemAt:[\"$array\", -1]}, ?0]}}")
    ReturnType MethodName(ArgType arg);

从 开始`Mongo 4.4`，聚合运算符[`$last`](https://docs.mongodb.com/master/reference/operator/aggregation/last-array-element/)可用于访问数组的最后一个元素：

* * *

例如，在`find`查询中：

    // { "myArray": ["A", "B", "C"] }
    // { "myArray": ["D"] }
    db.collection.find({ $expr: { $eq: [{ $last: "$myArray" }, "C"] } })
    // { "myArray": ["A", "B", "C"] }
    

* * *

或者在`aggregation`查询中：

    db.collection.aggregate([
      { $addFields: { last: { $last: "$myArray" } } },
      { $match: { last: "C" } }
    ])

使用**$slice**。

    db.collection.find( {}, { array_field: { $slice: -1 } } )
    

编辑：您可以使用它 `{ <field>: { $elemMatch: { <query1>, <query2>, ... } } }`来查找匹配项。

但它不会准确地给出您正在寻找的内容。我认为这在 mongoDB 中还不可能。

[我在](https://groups.google.com/forum/#!topic/mongodb-user/m2XB6KYs8Fw)Mongo Google 官方群组上发帖，并得到了他们工作人员的答复。看来我正在寻找的东西是不可能的。我将使用不同的模式方法。

Mongoose 如何查询数组的最后一个元素？

在Mongoose中，验证电子邮件格式通常是通过在Schema定义中使用正则表达式来完成的。Mongoose提供了一个名为`validate`的功能，它可以接受一个验证函数或者正则表达式以及一个错误消息。

以下是一个如何在Mongoose中定义一个简单的用户模型，并对电子邮件字段进行格式验证的例子：

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

// 定义正则表达式来验证电子邮件格式
const emailRegex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

// 创建一个新的用户模式
const userSchema = new Schema({
  email: {
    type: String,
    required: true,
    unique: true,
    // 使用正则表达式进行验证
    validate: {
      validator: function(email) {
        return emailRegex.test(email);
      },
      // 如果验证失败，Mongoose将使用此消息
      message: props => `${props.value} is not a valid email address!`
    }
  },
  // 其他字段定义...
});

// 创建模型
const User = mongoose.model('User', userSchema);

// 使用模型创建一个新用户实例
const user = new User({
  email: 'example@domain.com',
  // 其他字段值...
});

// 保存用户并处理可能出现的验证错误
user.save(function(err) {
  if (err) {
    // 如果电子邮件格式不正确，将会有一个验证错误
    console.error('Error occurred:', err.message);
  } else {
    console.log('User saved successfully!');
  }
});
```

在这个例子中，`emailRegex` 定义了电子邮件的验证规则，通过 `userSchema` 中的 `validate` 选项应用。如果提供的电子邮件不符合正则表达式的规则，Mongoose 会在尝试保存用户时抛出一个错误，并附带我们定义的错误消息。

需要注意的是，这个正则表达式只是一个基本的电子邮件验证规则，电子邮件地址的实际规则更为复杂，这个正则表达式不能覆盖所有有效的电子邮件地址格式。在实际应用中，可能需要使用更复杂的正则表达式或第三方库来更准确地验证电子邮件地址。

您还可以使用**match**或**validate**属性在模式中进行验证

例子

    var validateEmail = function(email) {
        var re = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
        return re.test(email)
    };
    
    var EmailSchema = new Schema({
        email: {
            type: String,
            trim: true,
            lowercase: true,
            unique: true,
            required: 'Email address is required',
            validate: [validateEmail, 'Please fill a valid email address'],
            match: [/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, 'Please fill a valid email address']
        }
    });

我使用[验证器](https://github.com/chriso/validator.js)来进行输入清理，它的使用方式非常酷。

安装它，然后像这样使用它：

    import { isEmail } from 'validator';
    // ... 
    
    const EmailSchema = new Schema({
        email: { 
            //... other setup
            validate: [ isEmail, 'invalid email' ]
        }
    });
    

工作起来很享受，而且读起来也很好。

您可以使用正则表达式。看看这个问题：[Validate email address in JavaScript?](https://stackoverflow.com/questions/46155/validate-email-address-in-javascript)

我过去用过这个。

    UserSchema.path('email').validate(function (email) {
       var emailRegex = /^([\w-\.]+@([\w-]+\.)+[\w-]{2,4})?$/;
       return emailRegex.test(email.text); // Assuming email has a text attribute
    }, 'The e-mail field cannot be empty.')

验证[器](https://www.npmjs.com/package/validator) 不能很好地与猫鼬一起摆脱警告设置 isAsync 为 false

    const validator = require('validator');
    
    email:{
    type:String,
    validate:{
          validator: validator.isEmail,
          message: '{VALUE} is not a valid email',
          isAsync: false
        }
    }

我知道这已经很旧了，但我没有看到这个解决方案，所以我想分享一下：

    const schema = new mongoose.Schema({
        email: {
            type: String,
            trim: true,
            lowercase: true,
            unique: true,
            validate: {
                validator: function(v) {
                    return /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(v);
                },
                message: "Please enter a valid email"
            },
            required: [true, "Email required"]
        }
    });
    

您可以对要验证的任何类型执行此操作，只需传递适当的正则表达式即可。如果您搜索要验证的类型及其相关的正则表达式，则很容易找到解决方案。这将使您的验证保持一致，并将所有代码放入架构中，而不是挂起函数。

Mongoose 如何验证电子邮件格式？

在Mongoose中，实现一对多关系通常涉及两个模型：父模型（例如“用户”）和子模型（例如“评论”），其中父模型会引用多个子模型的实例。以下是如何在Mongoose中实现这样的一对多关系：

首先，定义子模型的schema，例如评论模型：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

const commentSchema = new Schema({
  text: String,
  createdAt: {
    type: Date,
    default: Date.now
  },
  // 其他字段...
});

const Comment = mongoose.model('Comment', commentSchema);
```

接着，定义父模型的schema，并使用数组字段来引用子模型的ObjectId。Mongoose中的`ref`关键字用来指定引用的模型名称：

```javascript
const userSchema = new Schema({
  username: String,
  email: String,
  comments: [
    {
      type: Schema.Types.ObjectId,
      ref: 'Comment'
    }
  ]
  // 其他字段...
});

const User = mongoose.model('User', userSchema);
```

在这个例子中，每个用户可以有多个评论，用户模型中的`comments`字段是一个数组，存储了指向`Comment`模型document的ObjectId。

当需要查询用户及其相关的评论时，可以使用`populate()`函数来自动替换这些ObjectId为对应的评论文档：

```javascript
User.findById(userId)
  .populate('comments')
  .exec((err, user) => {
    if (err) {
      // 处理错误...
    }
    console.log(user.comments); // 这里的comments将会是Comment的文档数组
  });
```

在实际应用中，还可以进一步为`populate()`函数指定需要的字段，或者对结果进行排序、过滤等操作。

这样的引用关系是灵活的，因为可以独立地添加或删除评论，而不需要修改用户文档。同时，也能够轻松地查询到与特定用户相关的所有评论。不过，需要注意的是，如果一对多的关系中“多”的一方数量非常大，那么可能需要考虑分页或限制引用的数量，以避免性能问题。

参考[population](http://mongoosejs.com/docs/populate.html)，这里摘取Mongoose的一个例子。

    var mongoose = require('mongoose')
    , Schema = mongoose.Schema
    
    var personSchema = Schema({
      _id     : Schema.Types.ObjectId,
      name    : String,
      age     : Number,
      stories : [{ type: Schema.Types.ObjectId, ref: 'Story' }]
    });
    
    var storySchema = Schema({
      _creator : { type: Schema.Types.ObjectId, ref: 'Person' },
      title    : String,
      fans     : [{ type: Schema.Types.ObjectId, ref: 'Person' }]
    });
    
    var Story  = mongoose.model('Story', storySchema);
    var Person = mongoose.model('Person', personSchema);
    

`Story`因此，有关模型商店的示例`Person._id`与`Story._creator`. 当找到 的文档时`Story`，可以使用`populate()`方法来定义要`Person`同时检索模型中的哪个属性，例如：

    Story.findOne({_id: 'xxxxxxx'}).populate('person', 'name age').exec(function(err, story) {
      console.log('Story title: ', story.title);
      console.log('Story creator', story.person.name);
    });
    

我相信这就是您所寻找的。或者，您可以改用[嵌套集合](https://docs.mongodb.org/manual/tutorial/model-tree-structures-with-nested-sets/)。

这个问题的先前答案很有帮助，但查看更详细的代码可能会很有用。以下代码来自我的应用程序的 Express.js 后端。我的应用程序允许用户撰写评论。当查询用户时，我返回用户所做的所有评论。

用户模型.js

    import mongoose, { Schema } from 'mongoose';
    
    
    const UserSchema = new Schema({
      firstname: String,
      lastname: String,
      username: { type: String, unique: true },
      reviews: [{ type: Schema.Types.ObjectId, ref: 'Review' }],
    }, {
      toJSON: {
        virtuals: true,
      },
    });
    
    const UserModel = mongoose.model('User', UserSchema);
    export default UserModel;
    

review\_model.js

    import mongoose, { Schema } from 'mongoose';
    
    const ReviewSchema = new Schema({
      body: String,
      username: String,
      rating: Number,
    }, {
      toJSON: {
        virtuals: true,
      },
    });
    
    const ReviewModel = mongoose.model('Review', ReviewSchema);
    export default ReviewModel;
    

review\_controller.js

    // . . .
    export const createReview = (req, res) => {
        const review = new Review();
        review.username = req.body.username;
        review.rating = req.body.rating;
        review.body = req.body.body;
        review.save()
          .then((result) => {
            User.findOne({ username: review.username }, (err, user) => {
                if (user) {
                    // The below two lines will add the newly saved review's 
                    // ObjectID to the the User's reviews array field
                    user.reviews.push(review);
                    user.save();
                    res.json({ message: 'Review created!' });
                }
            });
          })
          .catch((error) => {
            res.status(500).json({ error });
          });
    };
    

用户控制器.js

     export const createUser = (req, res) => {
       const user = new User();
       user.username = req.body.username;
       user.email = req.body.email;
       user.save()
           .then((result) => {
                res.json({ message: 'User created!', result });
            })
            .catch((error) => {
              res.status(500).json({ error });
            });
        };
    
    // . . .
    // returns the user object associated with the username if any
    // with the reviews field containing an array of review objects 
    // consisting of the reviews created by the user
    export const getUser = (req, res) => {
        User.findOne({ username: req.params.username })
          .populate('reviews')
          .then((result) => {
            res.json(result);
          })
          .catch((error) => {
            res.status(500).json({ error });
          });
      };

正如[人口文档](http://mongoosejs.com/docs/populate.html)中所说

    var aaron = new Person({ _id: 0, name: 'Aaron', age: 100 });
    
    aaron.save(function (err) {
      if (err) return handleError(err);
    
      var story1 = new Story({
        title: "Once upon a timex.",
        _creator: aaron._id    // assign the _id from the person
      });
    
      story1.save(function (err) {
        if (err) return handleError(err);
        // thats it!
      });
      //then add story to person
      aaron.stories.push(story1);
      aaron.save(callback);
    });

这是创建一对多关系的好方法。

1.  首先，我们在Comment.js中定义Comment模型。

    const mongoose = require("mongoose");
    
    const Comment = mongoose.model(
      "Comment",
      new mongoose.Schema({
        username: String,
        text: String,
        createdAt: Date
      })
    );
    
    module.exports = Comment;
    

2.  在Tutorial.js中，添加注释数组，如下所示：

    
    
    const mongoose = require("mongoose");
    
    const Tutorial = mongoose.model(
      "Tutorial",
      new mongoose.Schema({
        title: String,
        author: String,
        images: [],
        comments: [
          {
            type: mongoose.Schema.Types.ObjectId,
            ref: "Comment"
          }
        ]
      })
    );
    
    module.exports = Tutorial;
    

3.  在server.js中，添加createComment函数。

    
    const createComment = function(tutorialId, comment) {
      return db.Comment.create(comment).then(docComment => {
        console.log("\n>> Created Comment:\n", docComment);
    
        return db.Tutorial.findByIdAndUpdate(
          tutorialId,
          { $push: { comments: docComment._id } },
          { new: true, useFindAndModify: false }
        );
      });
    };

**单向或双向关系**

您可能会考虑另一种可能性：您_真的_需要双向关联吗？`_creator`或者只将其存储在每个中就足够了`Story`。并且不要_存储_for `list of stories`every `Person`。故事列表仍然可以在搜索中查询：

    let allStoriesOfOneCreator = Stories.find({_creator: person._id});
    

[https://docs.mongodb.com/manual/tutorial/model-referenced-one-to-many-relationships- Between-documents/](https://docs.mongodb.com/manual/tutorial/model-referenced-one-to-many-relationships-between-documents/)

最终这取决于您的应用程序的要求。您多久需要一次创作者的故事？

如何在猫鼬中引用一对多关系

在使用Mongoose操作MongoDB时，有时候需要执行一系列的数据库操作，比如检索一个文档然后更新它。在Mongoose中，可以使用多种方式来“合并”两次请求操作，使得它们能够顺利协作完成一项任务。

以下是一些常见的方式来合并两次请求操作：

### 1. Callbacks
最基础的方式是使用嵌套的回调函数。首先执行第一个操作，在其回调函数中执行第二个操作。

```javascript
Model.findOne({ name: 'John Doe' }, (err, user) => {
  if (err) throw err;
  if (user) {
    user.age = 30;
    user.save((err) => {
      if (err) throw err;
      // 这里处理额外的逻辑，因为两个操作已经合并完成
    });
  }
});
```

### 2. Promises
Promises 提供了一个更加优雅的方式来处理异步操作。你可以连续使用 `.then()` 来处理多个步骤。

```javascript
Model.findOne({ name: 'John Doe' })
  .then(user => {
    if (!user) throw new Error('User not found');
    user.age = 30;
    return user.save();
  })
  .then(() => {
    // 这里处理额外的逻辑
  })
  .catch(err => {
    // 处理出错的情况
  });
```

### 3. Async/Await
使用 ES7 的 async/await 可以写出更加直观和同步的风格代码，同时保持异步操作的优势。

```javascript
async function updateUserAge() {
  try {
    const user = await Model.findOne({ name: 'John Doe' });
    if (!user) throw new Error('User not found');

    user.age = 30;
    await user.save();

    // 这里处理额外的逻辑
  } catch (err) {
    // 处理出错的情况
  }
}

updateUserAge();
```

### 4. Mongoose Middleware (Pre/Post Hooks)
Mongoose 允许你定义 pre 和 post 钩子（hooks），它们可以在某些操作执行前后自动运行。这可以用于合并像验证或者自动填充等操作。

```javascript
schema.pre('save', function(next) {
  // 在文档保存之前执行一些操作
  next();
});

schema.post('save', function(doc) {
  // 在文档保存之后执行一些操作
});
```

### 5. 事务（Transactions）
MongoDB 4.0 以上版本支持多文档事务。如果需要合并的操作涉及到多个文档或集合的变更，可以使用事务来保证数据的一致性。

```javascript
const session = await mongoose.startSession();
session.startTransaction();

try {
  const opts = { session };
  const user = await Model.findOne({ name: 'John Doe' }, null, opts);
  user.age = 30;
  await user.save(opts);

  // 可以在此添加更多操作，它们都将成为这个事务的一部分

  await session.commitTransaction();
  session.endSession();
} catch (err) {
  await session.abortTransaction();
  session.endSession();
  throw err;
}
```

在实际的应用中，这些方法可以根据具体的业务逻辑和操作的复杂度来选择。代码的可维护性、错误处理方式、以及对并发操作的处理都是选择合适方法时需要考虑的因素。

It's probably easiest to create your query object directly as:

      Test.find({
          $and: [
              { $or: [{a: 1}, {b: 1}] },
              { $or: [{c: 1}, {d: 1}] }
          ]
      }, function (err, results) {
          ...
      }
    

But you can also use the [`Query#and`](http://mongoosejs.com/docs/api.html#query_Query-and) helper that's available in recent 3.x Mongoose releases:

      Test.find()
          .and([
              { $or: [{a: 1}, {b: 1}] },
              { $or: [{c: 1}, {d: 1}] }
          ])
          .exec(function (err, results) {
              ...
          });

在 Mongoose 中，要使用 AND 组合两个 OR 查询，可以使用查询构造器来添加复杂的查询条件。Mongoose 提供了 `.and()` 方法来指定 AND 条件，同时 `.or()` 方法用于指定 OR 条件。每个 `.or()` 方法调用可以包含一个条件数组，表示所有数组内的条件中至少有一个要为真。

下面我将通过一个例子来说明如何在 Mongoose 中组合两个 OR 查询。

设想我们有一个用户模型，包含字段 `name` 和 `status`，我们想找到以下两组用户的并集：

1. 名字是 "Alice" 或 "Bob" 的用户。
2. 状态为 "active" 或 "pending" 的用户。

此时我们需要组合两个 OR 查询，可以这么做：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 假设有如下用户模型
const UserSchema = new Schema({
  name: String,
  status: String
});

const User = mongoose.model('User', UserSchema);

User.find()
  .and([
    { $or: [{ name: 'Alice' }, { name: 'Bob' }] },
    { $or: [{ status: 'active' }, { status: 'pending' }] }
  ])
  .exec((err, users) => {
    if (err) throw err;
    // 处理查询到的用户
    console.log(users);
  });
```

在这个例子中，`.find()` 方法首先被调用，然后是 `.and()` 方法，它接受一个数组作为参数。这个数组包含了两个对象，每个对象都是一个 OR 查询。第一个 OR 查询 `{ $or: [{ name: 'Alice' }, { name: 'Bob' }] }` 表示查找名字为 "Alice" 或者 "Bob" 的用户，第二个 OR 查询 `{ $or: [{ status: 'active' }, { status: 'pending' }] }` 表示查找状态为 "active" 或者 "pending" 的用户。这两个 OR 查询通过 AND 条件组合，最终结果是同时满足这两个条件的用户集合。

请注意，每个 `.or()` 查询实际上是通过 `$or` 操作符实现的，这是 MongoDB 的查询语法。Mongoose 使得构建这种查询变得更为直观。

还有其他方式来实现相同的查询，例如直接在 `.find()` 方法中构造查询对象：

```javascript
User.find({
  $and: [
    { $or: [{ name: 'Alice' }, { name: 'Bob' }] },
    { $or: [{ status: 'active' }, { status: 'pending' }] }
  ]
})
.exec((err, users) => {
  if (err) throw err;
  // 处理查询到的用户
  console.log(users);
});
```

这种方法直接将 AND 和 OR 查询组合为一个查询对象，然后将其作为 `.find()` 方法的参数传递。两种方法在功能上是等价的，你可以根据自己的喜好和具体需求选择使用。

Mongoose 如何合并两次请求操作？

Mongoose 是一个 MongoDB 对象模型库，用于在 Node.js 环境中以对象映射文档（Object-Document Mapping，ODM）的方式操作 MongoDB 数据库。`.save()` 方法和 `update()` 方法都用于在数据库中持久化文档数据，但它们之间存在一些关键区别：

### `.save()` 方法

1. **创建或更新：** `.save()` 通常用于保存一个新的文档实例或更新现有的文档。如果保存的文档实例具有 `_id` 字段并且在数据库中能找到对应的记录，那么它会执行更新操作。如果没有 `_id` 字段或者 `_id` 在数据库中找不到匹配的记录，则会创建一个新记录。

2. **全文档操作：** 当你使用 `.save()` 时，你通常是在操作整个文档。无论是创建新文档还是更新现有文档，你都会发送整个文档的数据到数据库。

3. **中间件触发：** `.save()` 方法会触发 Mongoose 的中间件（如 `pre` 和 `post` 钩子）。这意味着在保存过程中，可以执行自定义逻辑（如密码加密、数据验证等）。

4. **返回值：** `.save()` 方法执行后，会返回被保存的文档对象。

5. **示例：**
    ```javascript
    const user = new UserModel({
      name: 'Alice',
      email: 'alice@example.com'
    });
    user.save(function(err, savedUser) {
      if (err) throw err;
      // savedUser 是保存后的文档对象
    });
    ```

### `update()` 方法

1. **只用于更新：** `.update()` 方法仅用于更新已存在的文档。它不能用于创建新文档。

2. **部分文档操作：** 当你使用 `.update()` 方法时，你可以只更新文档的某些部分，而不是发送整个文档。这通常用于性能优化，因为只传输需要更新的字段。

3. **没有中间件触发：** 使用 `.update()` 方法时，通常不会触发 Mongoose 中间件。如果需要在更新操作前后执行特定逻辑，可能需要手动处理。

4. **返回值：** `.update()` 方法执行后，返回的是一个包含操作结果的对象，如更新的文档数量，而不是更新后的文档对象。

5. **示例：**
    ```javascript
    UserModel.update({ _id: userId }, { $set: { name: 'Bob' } }, function(err, result) {
      if (err) throw err;
      // result 是操作结果对象，可以通过 result.nModified 获取被更新的文档数量
    });
    ```

总结一下，`.save()` 用于创建新文档或替换整个文档，而 `.update()` 用于修改现有文档的部分字段。`.save()` 方法会触发中间件，返回保存的文档；`.update()` 方法不触发中间件，返回操作的结果。根据具体的应用场景和性能考虑，开发者可以选择最合适的方法进行数据库操作。### 应用场景比较

#### `.save()` 方法的应用场景：

- **新建文档场景**：当你有一个全新的文档并打算将其添加到数据库中时，可以使用 `.save()` 来实现。例如，当一个新用户注册到你的应用时，你需要创建一个新的用户文档。

- **完整文档更新场景**：如果你需要更新文档，并且更新涉及许多字段，或者你已经在应用层加载并可能修改了整个文档，那么使用 `.save()` 方法更新整个文档可能更为方便。

- **需要中间件处理的场景**：当你的保存逻辑需要触发 Mongoose 中间件，比如数据验证、自动设置时间戳、散列密码等操作时，`.save()` 方法是更好的选择。

#### `.update()` 方法的应用场景：

- **部分更新场景**：当你需要更新文档中的一个或几个字段，并且不需要加载整个文档时，`.update()` 是一个更高效的选择。这常见于需要快速响应的Web应用中。

- **批量更新场景**：当你需要更新多个文档且每个文档的更新都是相同的操作时，`.update()` 方法可以通过一次操作来更新所有匹配的文档，这通常比逐一加载文档并调用 `.save()` 更有效率。

- **无需中间件场景**：如果你不需要触发保存过程中的中间件，比如在执行一些批量操作或后台任务时，`.update()` 可以避免中间件的性能开销。

### 直接修改和替换文档

- **`.save()` 替换文档**：当你使用 `.save()` 方法时，如果文档存在 `_id` 字段且该 `_id` 在数据库中找到了对应的记录，Mongoose 会替换掉原来的文档。这意味着，如果有些字段在新文档中没有指定，它们将从数据库中的文档里被移除。

- **`.update()` 修改字段**：与 `.save()` 不同，`.update()` 方法默认仅修改指定的字段，而不会影响未指定的字段。对于需要保留其他字段内容的场合，这通常是更加安全和预期的行为。

### 性能考量

- **性能优化**：在大型应用中，`.update()` 方法对性能的影响通常小于 `.save()` 方法。特别是在进行部分字段更新时，`.update()` 方法不需要发送整个文档数据，也不需要加载文档到应用层，从而减少了网络传输和内存使用。

- **原子操作**：`.update()` 方法允许使用 MongoDB 的原子更新操作符，如 `$set`, `$inc`, `$push` 等，这样可以确保更新操作的原子性，防止在并发场景下出现数据不一致的问题。

### 总结

根据你的需要，你可能会选择使用 `.save()` 或 `.update()`——或者是 Mongoose 提供的其他相关方法，如 `.updateOne()`, `.updateMany()`, `.findOneAndUpdate()` 等，这些方法提供了不同的功能和性能取舍。选择哪一种方法取决于你的具体需求，比如是否需要处理整个文档，是否需要触发中间件，是否关注性能优化，以及操作的原子性等因素。

先说两个概念。您的应用程序是**客户端**，Mongodb 是**服务器**。

主要区别在于，`.save()`您的客户端代码中已经有一个对象，或者在写回数据之前必须从服务器检索数据，并且您正在写回整个内容。

另一方面`.update()`不需要**将**数据从服务器加载到客户端。所有交互都发生在服务器端，而不检索到客户端。因此，`.update()`当您向现有文档添加内容时，这种方式可以非常有效。

此外，还有一个`multi`参数`.update()`允许对多个符合查询条件的文档执行操作。

当用作调用时，便利方法中的一些东西你会失去`.update()`，但某些操作的好处是你必须承担的“权衡”。有关此内容以及可用选项的更多信息，请参阅[文档](http://mongoosejs.com/docs/api.html#model_Model.update)。

简而言之`.save()`是客户端接口，`.update()`是服务器端。

一些差异：

*   正如其他地方所指出的，它比其次`update`更有效，因为它避免了加载整个文档。`find``save`
*   Mongoose`update`会转换为 MongoDB `update`，但 Mongoose`save`会转换为 MongoDB `insert`（用于新文档）或`update`.
*   需要注意的是`save`，[Mongoose 在内部比较文档](https://github.com/Automattic/mongoose/blob/168f516902bf142006581479d58d19867fb844e8/lib/model.js#L146)并仅发送实际更改的字段。这有利于原子性。
*   默认情况下，[验证不会运行](https://www.mongodb.com/blog/post/introducing-version-40-mongoose-nodejs-odm)，`update`但可以启用。
*   中间件 API（`pre`和`post`钩子）是不同的。

Mongoose 有一个有用的功能，称为中间件。有“前”和“后”中间件。中间件会在您执行“保存”时执行，但不会在“更新”期间执行。例如，如果您想在每次修改密码时对 User schema 中的密码进行哈希处理，则可以使用 pre 来执行此操作，如下所示。另一个有用的示例是为每个文档设置lastModified。[该文档可以在http://mongoosejs.com/docs/middleware.html](http://mongoosejs.com/docs/middleware.html)找到[](http://mongoosejs.com/docs/middleware.html)

    UserSchema.pre('save', function(next) {
    var user = this;
    // only hash the password if it has been modified (or is new)
    if (!user.isModified('password')) {
        console.log('password not modified');
        return next();
    }
    console.log('password modified');
    // generate a salt
    bcrypt.genSalt(10, function(err, salt) {
        if (err) {
            return next(err);
        }
    
        // hash the password along with our new salt
        bcrypt.hash(user.password, salt, function(err, hash) {
            if (err) {
                return next(err);
            }
            // override the cleartext password with the hashed one
            user.password = hash;
            next();
        });
    });
    });

一个不容忽视的细节：**并发性**

正如前面提到的，在执行操作时`doc.save()`，您必须先将文档加载到内存中，然后对其进行修改，最后将`doc.save()`更改发送到 MongoDB 服务器。

**当同时以**这种方式编辑文档时就会出现问题：

*   A 加载文档 (v1)
*   B 加载文档 (v1)
*   B 保存对文档的更改（现在是 v2）
*   A 保存对过时 (v1) 文档的更改
*   A 会看到 Mongoose 抛出 VersionError，因为文档自上次从集合加载以来已发生更改

在执行像这样的原子操作时，并发不是问题`Model.updateOne()`，因为操作完全在 MongoDB 服务器中完成，MongoDB 服务器执行一定程度的**[并发控制](https://docs.mongodb.com/manual/faq/concurrency/)**。

因此，要小心！

Mongoose 是一个 MongoDB 对象模型库，用于在 Node.js 环境中以对象映射文档（Object-Document Mapping，ODM）的方式操作 MongoDB 数据库。`.save()` 方法和 `update()` 方法都用于在数据库中持久化文档数据，但它们之间存在一些关键区别：

### `.save()` 方法

1. **创建或更新：** `.save()` 通常用于保存一个新的文档实例或更新现有的文档。如果保存的文档实例具有 `_id` 字段并且在数据库中能找到对应的记录，那么它会执行更新操作。如果没有 `_id` 字段或者 `_id` 在数据库中找不到匹配的记录，则会创建一个新记录。

2. **全文档操作：** 当你使用 `.save()` 时，你通常是在操作整个文档。无论是创建新文档还是更新现有文档，你都会发送整个文档的数据到数据库。

3. **中间件触发：** `.save()` 方法会触发 Mongoose 的中间件（如 `pre` 和 `post` 钩子）。这意味着在保存过程中，可以执行自定义逻辑（如密码加密、数据验证等）。

4. **返回值：** `.save()` 方法执行后，会返回被保存的文档对象。

5. **示例：**
    ```javascript
    const user = new UserModel({
      name: 'Alice',
      email: 'alice@example.com'
    });
    user.save(function(err, savedUser) {
      if (err) throw err;
      // savedUser 是保存后的文档对象
    });
    ```

### `update()` 方法

1. **只用于更新：** `.update()` 方法仅用于更新已存在的文档。它不能用于创建新文档。

2. **部分文档操作：** 当你使用 `.update()` 方法时，你可以只更新文档的某些部分，而不是发送整个文档。这通常用于性能优化，因为只传输需要更新的字段。

3. **没有中间件触发：** 使用 `.update()` 方法时，通常不会触发 Mongoose 中间件。如果需要在更新操作前后执行特定逻辑，可能需要手动处理。

4. **返回值：** `.update()` 方法执行后，返回的是一个包含操作结果的对象，如更新的文档数量，而不是更新后的文档对象。

5. **示例：**
    ```javascript
    UserModel.update({ _id: userId }, { $set: { name: 'Bob' } }, function(err, result) {
      if (err) throw err;
      // result 是操作结果对象，可以通过 result.nModified 获取被更新的文档数量
    });
    ```

总结一下，`.save()` 用于创建新文档或替换整个文档，而 `.update()` 用于修改现有文档的部分字段。`.save()` 方法会触发中间件，返回保存的文档；`.update()` 方法不触发中间件，返回操作的结果。根据具体的应用场景和性能考虑，开发者可以选择最合适的方法进行数据库操作。

Mongoose 是一个 MongoDB 对象模型库，用于在 Node.js 环境中以对象映射文档（Object-Document Mapping，ODM）的方式操作 MongoDB 数据库。`.save()` 方法和 `update()` 方法都用于在数据库中持久化文档数据，但它们之间存在一些关键区别：

### `.save()` 方法

1. **创建或更新：** `.save()` 通常用于保存一个新的文档实例或更新现有的文档。如果保存的文档实例具有 `_id` 字段并且在数据库中能找到对应的记录，那么它会执行更新操作。如果没有 `_id` 字段或者 `_id` 在数据库中找不到匹配的记录，则会创建一个新记录。

2. **全文档操作：** 当你使用 `.save()` 时，你通常是在操作整个文档。无论是创建新文档还是更新现有文档，你都会发送整个文档的数据到数据库。

3. **中间件触发：** `.save()` 方法会触发 Mongoose 的中间件（如 `pre` 和 `post` 钩子）。这意味着在保存过程中，可以执行自定义逻辑（如密码加密、数据验证等）。

4. **返回值：** `.save()` 方法执行后，会返回被保存的文档对象。

5. **示例：**
    ```javascript
    const user = new UserModel({
      name: 'Alice',
      email: 'alice@example.com'
    });
    user.save(function(err, savedUser) {
      if (err) throw err;
      // savedUser 是保存后的文档对象
    });
    ```

### `update()` 方法

1. **只用于更新：** `.update()` 方法仅用于更新已存在的文档。它不能用于创建新文档。

2. **部分文档操作：** 当你使用 `.update()` 方法时，你可以只更新文档的某些部分，而不是发送整个文档。这通常用于性能优化，因为只传输需要更新的字段。

3. **没有中间件触发：** 使用 `.update()` 方法时，通常不会触发 Mongoose 中间件。如果需要在更新操作前后执行特定逻辑，可能需要手动处理。

4. **返回值：** `.update()` 方法执行后，返回的是一个包含操作结果的对象，如更新的文档数量，而不是更新后的文档对象。

5. **示例：**
    ```javascript
    UserModel.update({ _id: userId }, { $set: { name: 'Bob' } }, function(err, result) {
      if (err) throw err;
      // result 是操作结果对象，可以通过 result.nModified 获取被更新的文档数量
    });
    ```

总结一下，`.save()` 用于创建新文档或替换整个文档，而 `.update()` 用于修改现有文档的部分字段。`.save()` 方法会触发中间件，返回保存的文档；`.update()` 方法不触发中间件，返回操作的结果。根据具体的应用场景和性能考虑，开发者可以选择最合适的方法进行数据库操作。
### 应用场景比较

#### `.save()` 方法的应用场景：

- **新建文档场景**：当你有一个全新的文档并打算将其添加到数据库中时，可以使用 `.save()` 来实现。例如，当一个新用户注册到你的应用时，你需要创建一个新的用户文档。

- **完整文档更新场景**：如果你需要更新文档，并且更新涉及许多字段，或者你已经在应用层加载并可能修改了整个文档，那么使用 `.save()` 方法更新整个文档可能更为方便。

- **需要中间件处理的场景**：当你的保存逻辑需要触发 Mongoose 中间件，比如数据验证、自动设置时间戳、散列密码等操作时，`.save()` 方法是更好的选择。

#### `.update()` 方法的应用场景：

- **部分更新场景**：当你需要更新文档中的一个或几个字段，并且不需要加载整个文档时，`.update()` 是一个更高效的选择。这常见于需要快速响应的Web应用中。

- **批量更新场景**：当你需要更新多个文档且每个文档的更新都是相同的操作时，`.update()` 方法可以通过一次操作来更新所有匹配的文档，这通常比逐一加载文档并调用 `.save()` 更有效率。

- **无需中间件场景**：如果你不需要触发保存过程中的中间件，比如在执行一些批量操作或后台任务时，`.update()` 可以避免中间件的性能开销。

### 直接修改和替换文档

- **`.save()` 替换文档**：当你使用 `.save()` 方法时，如果文档存在 `_id` 字段且该 `_id` 在数据库中找到了对应的记录，Mongoose 会替换掉原来的文档。这意味着，如果有些字段在新文档中没有指定，它们将从数据库中的文档里被移除。

- **`.update()` 修改字段**：与 `.save()` 不同，`.update()` 方法默认仅修改指定的字段，而不会影响未指定的字段。对于需要保留其他字段内容的场合，这通常是更加安全和预期的行为。

### 性能考量

- **性能优化**：在大型应用中，`.update()` 方法对性能的影响通常小于 `.save()` 方法。特别是在进行部分字段更新时，`.update()` 方法不需要发送整个文档数据，也不需要加载文档到应用层，从而减少了网络传输和内存使用。

- **原子操作**：`.update()` 方法允许使用 MongoDB 的原子更新操作符，如 `$set`, `$inc`, `$push` 等，这样可以确保更新操作的原子性，防止在并发场景下出现数据不一致的问题。

### 总结

根据你的需要，你可能会选择使用 `.save()` 或 `.update()`——或者是 Mongoose 提供的其他相关方法，如 `.updateOne()`, `.updateMany()`, `.findOneAndUpdate()` 等，这些方法提供了不同的功能和性能取舍。选择哪一种方法取决于你的具体需求，比如是否需要处理整个文档，是否需要触发中间件，是否关注性能优化，以及操作的原子性等因素。

Mongoose 中 save 和 update 有什么区别？

在使用Mongoose操作MongoDB时，您可以通过不同的方式删除数据库中的数据。以下是几种删除操作的方法：

### 删除文档

1. **使用`remove`方法**：这是删除匹配条件的所有文档的传统方法。但请注意，从Mongoose v5.0开始，`remove`方法已被弃用，建议使用`deleteOne`或`deleteMany`。

    ```javascript
    // 假设我们有一个名为Model的模型
    Model.remove({ _id: '某个特定的ID' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("文档删除成功");
        }
    });
    ```

2. **使用`deleteOne`方法**：这是用来删除第一个匹配条件的单个文档的方法。

    ```javascript
    Model.deleteOne({ name: '待删除的名称' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("单个文档删除成功");
        }
    });
    ```

3. **使用`deleteMany`方法**：这是用来删除所有匹配条件的文档的方法。

    ```javascript
    Model.deleteMany({ age: { $gte: 18 } }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("多个文档删除成功");
        }
    });
    ```

### 删除集合

如果您想要删除整个集合，您可以调用集合的`drop`方法。请谨慎使用，因为这会删除整个集合及其所有文档。

```javascript
mongoose.connection.db.dropCollection('collectionName', function(err, result) {
    if(err) {
        console.error("删除集合失败！", err);
    } else {
        console.log("集合删除成功", result);
    }
});
```

### 删除数据库

如果您需要删除整个数据库，可以使用MongoDB原生驱动的`dropDatabase`方法。这将删除当前连接的数据库，包括所有的集合和文档。

```javascript
mongoose.connection.db.dropDatabase(function(err, result) {
    if(err) {
        console.error("删除数据库失败！", err);
    } else {
        console.log("数据库删除成功", result);
    }
});
```

在执行这些删除操作时，一定要小心谨慎，因为它们会永久移除数据。在删除操作之前，确保您有相关数据的备份，或已经确认这些数据不再需要了。在开发阶段，可以在测试数据库上操作，以避免对生产数据库造成不必要的风险。### 确认删除操作

删除数据是一个危险的操作，尤其是在生产环境下。因此，在执行删除之前，您应该确保实施一些确认步骤，比如：

- **备份数据**：在删除任何数据之前，确保您已经备份了数据库或相应的数据集。
- **双重确认**：在执行删除操作之前，最好有一个提示让用户确认他们确实想要删除数据。
- **权限检查**：确保只有拥有适当权限的用户才能删除数据。

### 使用事务处理（在支持的情况下）

如果您的MongoDB版本支持事务（如MongoDB 4.0及以上的副本集），您可能想要在事务中执行删除操作。这样，如果事务中的某个部分失败，所有更改都可以回滚，从而避免了数据不一致的风险。

```javascript
const session = await mongoose.startSession();
session.startTransaction();
try {
    await Model.deleteMany({}, { session });
    // ... 可能还有其他数据库操作 ...
    await session.commitTransaction();
} catch (error) {
    await session.abortTransaction();
    throw error;
} finally {
    session.endSession();
}
```

### 软删除

有时候，您可能并不想从数据库中完全删除数据，而是想进行所谓的"软删除"。软删除通常意味着将文档标记为已删除，而实际上并不从数据库中移除它们。这可以通过在文档上添加一个`isDeleted`字段来实现，并在查询时过滤掉这些被标记为`isDeleted`的文档。

```javascript
// 软删除示例
Model.updateMany({}, { $set: { isDeleted: true } }, function(err) {
    if(err) {
        console.error("软删除失败！", err);
    } else {
        console.log("文档已被软删除");
    }
});

// 查询时跳过软删除的文档
Model.find({ isDeleted: { $ne: true } }).exec(function(err, docs) {
    // 返回未被软删除的文档
});
```

软删除通常用于需要保留数据完整性或历史记录的场景。

### 总结

删除操作应该谨慎进行，以防止意外数据丢失。在进行删除之前，确认操作的必要性，备份数据库，并只允许具有相应权限的用户执行这些操作。在某些场景下，您可能会考虑软删除而不是硬删除数据，以便未来的恢复或审计。

There is no method for dropping a collection from mongoose, the best you can do is remove the content of one :

    Model.remove({}, function(err) { 
       console.log('collection removed') 
    });
    

But there is a way to access the mongodb native javascript driver, which can be used for this

    mongoose.connection.collections['collectionName'].drop( function(err) {
        console.log('collection dropped');
    });
    

### Warning

Make a backup before trying this in case anything goes wrong!

Mongoose will create a database if one does not already exist on connection, so once you make the connection, you can just query it to see if there is anything in it.

You can drop any database you are connected to:

    var mongoose = require('mongoose');
    /* Connect to the DB */
    mongoose.connect('mongodb://localhost/mydatabase',function(){
        /* Drop the DB */
        mongoose.connection.db.dropDatabase();
    });

If you modify @hellslam's solution like this then it will work

I use this technique to drop the Database after my integration tests

    //CoffeeScript
    mongoose = require "mongoose"
    conn = mongoose.connect("mongodb://localhost/mydb")
    
    conn.connection.db.dropDatabase()
    
    //JavaScript
    var conn, mongoose;
    mongoose = require("mongoose");
    conn = mongoose.connect("mongodb://localhost/mydb");
    
    conn.connection.db.dropDatabase();
    

HTH at least it did for me, so I decided to share =)

在使用Mongoose操作MongoDB时，您可以通过不同的方式删除数据库中的数据。以下是几种删除操作的方法：

### 删除文档

1. **使用`remove`方法**：这是删除匹配条件的所有文档的传统方法。但请注意，从Mongoose v5.0开始，`remove`方法已被弃用，建议使用`deleteOne`或`deleteMany`。

    ```javascript
    // 假设我们有一个名为Model的模型
    Model.remove({ _id: '某个特定的ID' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("文档删除成功");
        }
    });
    ```

2. **使用`deleteOne`方法**：这是用来删除第一个匹配条件的单个文档的方法。

    ```javascript
    Model.deleteOne({ name: '待删除的名称' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("单个文档删除成功");
        }
    });
    ```

3. **使用`deleteMany`方法**：这是用来删除所有匹配条件的文档的方法。

    ```javascript
    Model.deleteMany({ age: { $gte: 18 } }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("多个文档删除成功");
        }
    });
    ```

### 删除集合

如果您想要删除整个集合，您可以调用集合的`drop`方法。请谨慎使用，因为这会删除整个集合及其所有文档。

```javascript
mongoose.connection.db.dropCollection('collectionName', function(err, result) {
    if(err) {
        console.error("删除集合失败！", err);
    } else {
        console.log("集合删除成功", result);
    }
});
```

### 删除数据库

如果您需要删除整个数据库，可以使用MongoDB原生驱动的`dropDatabase`方法。这将删除当前连接的数据库，包括所有的集合和文档。

```javascript
mongoose.connection.db.dropDatabase(function(err, result) {
    if(err) {
        console.error("删除数据库失败！", err);
    } else {
        console.log("数据库删除成功", result);
    }
});
```

在执行这些删除操作时，一定要小心谨慎，因为它们会永久移除数据。在删除操作之前，确保您有相关数据的备份，或已经确认这些数据不再需要了。在开发阶段，可以在测试数据库上操作，以避免对生产数据库造成不必要的风险。

在使用Mongoose操作MongoDB时，您可以通过不同的方式删除数据库中的数据。以下是几种删除操作的方法：

### 删除文档

1. **使用`remove`方法**：这是删除匹配条件的所有文档的传统方法。但请注意，从Mongoose v5.0开始，`remove`方法已被弃用，建议使用`deleteOne`或`deleteMany`。

    ```javascript
    // 假设我们有一个名为Model的模型
    Model.remove({ _id: '某个特定的ID' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("文档删除成功");
        }
    });
    ```

2. **使用`deleteOne`方法**：这是用来删除第一个匹配条件的单个文档的方法。

    ```javascript
    Model.deleteOne({ name: '待删除的名称' }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("单个文档删除成功");
        }
    });
    ```

3. **使用`deleteMany`方法**：这是用来删除所有匹配条件的文档的方法。

    ```javascript
    Model.deleteMany({ age: { $gte: 18 } }, function(err) {
        if(err) {
            console.error("发生错误！", err);
        } else {
            console.log("多个文档删除成功");
        }
    });
    ```

### 删除集合

如果您想要删除整个集合，您可以调用集合的`drop`方法。请谨慎使用，因为这会删除整个集合及其所有文档。

```javascript
mongoose.connection.db.dropCollection('collectionName', function(err, result) {
    if(err) {
        console.error("删除集合失败！", err);
    } else {
        console.log("集合删除成功", result);
    }
});
```

### 删除数据库

如果您需要删除整个数据库，可以使用MongoDB原生驱动的`dropDatabase`方法。这将删除当前连接的数据库，包括所有的集合和文档。

```javascript
mongoose.connection.db.dropDatabase(function(err, result) {
    if(err) {
        console.error("删除数据库失败！", err);
    } else {
        console.log("数据库删除成功", result);
    }
});
```

在执行这些删除操作时，一定要小心谨慎，因为它们会永久移除数据。在删除操作之前，确保您有相关数据的备份，或已经确认这些数据不再需要了。在开发阶段，可以在测试数据库上操作，以避免对生产数据库造成不必要的风险。
### 确认删除操作

删除数据是一个危险的操作，尤其是在生产环境下。因此，在执行删除之前，您应该确保实施一些确认步骤，比如：

- **备份数据**：在删除任何数据之前，确保您已经备份了数据库或相应的数据集。
- **双重确认**：在执行删除操作之前，最好有一个提示让用户确认他们确实想要删除数据。
- **权限检查**：确保只有拥有适当权限的用户才能删除数据。

### 使用事务处理（在支持的情况下）

如果您的MongoDB版本支持事务（如MongoDB 4.0及以上的副本集），您可能想要在事务中执行删除操作。这样，如果事务中的某个部分失败，所有更改都可以回滚，从而避免了数据不一致的风险。

```javascript
const session = await mongoose.startSession();
session.startTransaction();
try {
    await Model.deleteMany({}, { session });
    // ... 可能还有其他数据库操作 ...
    await session.commitTransaction();
} catch (error) {
    await session.abortTransaction();
    throw error;
} finally {
    session.endSession();
}
```

### 软删除

有时候，您可能并不想从数据库中完全删除数据，而是想进行所谓的"软删除"。软删除通常意味着将文档标记为已删除，而实际上并不从数据库中移除它们。这可以通过在文档上添加一个`isDeleted`字段来实现，并在查询时过滤掉这些被标记为`isDeleted`的文档。

```javascript
// 软删除示例
Model.updateMany({}, { $set: { isDeleted: true } }, function(err) {
    if(err) {
        console.error("软删除失败！", err);
    } else {
        console.log("文档已被软删除");
    }
});

// 查询时跳过软删除的文档
Model.find({ isDeleted: { $ne: true } }).exec(function(err, docs) {
    // 返回未被软删除的文档
});
```

软删除通常用于需要保留数据完整性或历史记录的场景。

### 总结

删除操作应该谨慎进行，以防止意外数据丢失。在进行删除之前，确认操作的必要性，备份数据库，并只允许具有相应权限的用户执行这些操作。在某些场景下，您可能会考虑软删除而不是硬删除数据，以便未来的恢复或审计。

Mongoose 如何删除数据库？

`exec` 函数在 Mongoose 中用于执行一个查询并返回一个 promise。当你使用 Mongoose 构建查询时，直到你调用 `exec`，`then`，`catch`，或者使用 `await` 时，查询才会被发送到 MongoDB 数据库执行。

在 Mongoose 中，查询构建器允许链式调用各种方法来构建一个复杂的查询。例如，你可能会使用 `find`，`sort`，`limit`，`select` 等方法。调用 `exec` 是在链式构建完成之后触发实际数据库操作的一种方式。

这里有一个例子：

```javascript
const mongoose = require('mongoose');
const { Schema } = mongoose;

// 假设我们有一个名为 User 的模型
const UserSchema = new Schema({
  name: String,
  age: Number,
  email: String
});

const User = mongoose.model('User', UserSchema);

// 构建一个查询来查找所有年龄在30岁以上的用户，并按照名称进行排序
User.find({ age: { $gt: 30 } })
  .sort('name')
  .select('name email')
  .exec() // 在这里，exec() 会执行上面构建的查询
  .then(users => {
    // 处理查询结果
    console.log(users);
  })
  .catch(err => {
    // 处理可能发生的错误
    console.error(err);
  });
```

在这个例子中，`exec` 返回一个 promise，该 promise 在查询成功执行后解析查询结果，在出现错误时拒绝。

使用 `exec` 的优势是可以让你更灵活地处理结果和错误，例如可以使用 `async/await` 语法，这样代码更加简洁和现代：

```javascript
async function findUsers() {
  try {
    const users = await User.find({ age: { $gt: 30 } })
      .sort('name')
      .select('name email')
      .exec(); // 使用 async/await 等待查询结果
    console.log(users);
  } catch (err) {
    console.error(err);
  }
}

findUsers();
```

在这个例子中，我们通过 `await` 关键字等待 `exec()` 的结果，这样就可以用同步代码的方式写异步操作，提高代码的可读性和维护性。

Basically when using mongoose, documents can be retrieved using helpers. Every model method that accepts query conditions can be executed by means of a `callback` or the `exec` method.

`callback`:

    User.findOne({ name: 'daniel' }, function (err, user) {
      //
    });
    

`exec`:

    User
      .findOne({ name: 'daniel' })
      .exec(function (err, user) {
          //
      });
    

Therefore when you don't pass a callback you can build a query and eventually execute it.

You can find additional info in the [mongoose docs](http://mongoosejs.com/docs/queries.html "mongoose docs").

**UPDATE**

Something to note when using [Promises](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise) in combination with Mongoose async operations is that Mongoose queries are **not** Promises. Queries do return a _thenable_, but if you need a _real_ Promise you should use the `exec` method. More information can be found [here](http://mongoosejs.com/docs/promises.html).

During the update I noticed I didn't explicitly answer the question:

> Ive never seen that method in Javascript before? What does it do exactly?

Well it's **not** a native JavaScript method, but part of the Mongoose API.

I never use `exec()` function to complete a CRUD(Create, Read, Update, Delete) on a model. When I want CRUD on a model, I use it like this:

    const user = await UserModel.findOne(userCondition);
    

And it always does the job. So I wondered "what does `exec()` use for"? As I searched in mongoose document, I found the answer [here](https://mongoosejs.com/docs/promises.html).  

> Should You Use exec() With await?  

And here is the story.  
You have two ways to execute a query on a model. Using `callback` or using `exec()` function. "But" you can use `await` too. `exec()` function returns a promise, that you can use it with `then()` or `async/await` to execute a query on a model "asynchronous". So the question is "If I can just use `user = await UserModel.find()` and it works currectly, so why should I use `exec()` function?". The answer that you can find in the [document](https://mongoosejs.com/docs/promises.html) is:  
  
There are two difference between using `await` with `exec()` or without it.  

*   As a functionality point of view, there is no difference between using `await` with `exec()` or without it. Just when you call a query without `exec()` or `callback`, it returns a `thenable` which is something like promise but it's not a promise.(You can find the difference [here](https://mongoosejs.com/docs/queries.html#queries-are-not-promises)). But when you use `exec()` to run a query, you get exactly a promise as response.

    // returns a thenable as response that is not a promise, but you can use await and then() with it.
    const user = await UserModel.findOne(userCondition);
    
    // returns exactly a promise.
    const user = await UserModel.findOne(userCondition).exec(); 
    

*   Another difference is, if you use `await` with `exec()` you get a better "stack trace" if you catch any error in executing queries. So:  
      
    These two line, do the same thing:

    const user = await UserModel.findOne(userCondition);
    
    // does exactly as the before line does, but you get a better stack trace if any error happened
    const user = await UserModel.findOne(userCondition).exec();

Daniel has answered this quite beautifully. To elaborate on an exhaustive list of ways to build and execute queries, look at the following use cases:

**Query Building**

Mongoose will not execute a query until `then` or `exec` has been called upon it. This is very useful when building complex queries. Some examples can include using the `populate` and `aggregate` functions.

    User.find({name: 'John'}) // Will not execute
    

**Execution via callback**

Although disliked by many due to its nesting nature, queries can be executed by providing the optional callback.

    User.find({name: 'John'}, (err, res) => {}) // Will execute
    

**Then API as a Promises/A+**

Mongoose queries do provide a `then` function. This is not to be confused with regular promises. Simply put, the Promises/A+ specification requires a `then` function to work much like how we're used to with promises.

    User.find({name: 'John'}).then(); // Will execute
    Promise.all([User.find({name: 'John'}), User.find({name: 'Bob'})]) // Will execute all queries in parallel
    

**The exec function**

From Mongoose docs `If you need a fully-fledged promise, use the .exec() function.`

    User.find({name: 'John'}).exec(); // Will execute returning a promise

`exec()` will return a promise if no callback is provided. So the following pattern is very convenient and generic - it can handle callbacks or promises nicely:

    function findAll(query, populate, cb) {
    
      let q = Response.find(query);
    
      if (populate && populate.length > 0) {
        q = q.populate(populate);
      }
    
      // cb is optional, will return promise if cb == null
      return q.lean().exec(cb);
    
    }
    

I recommend using Bluebird promises with Mongoose, to do that, use this call:

    const mongoose = require('mongoose');
    mongoose.Promise = require('bluebird');

all answers are correct but the easiest way is to use modern async await approach..

    async ()=> {
    const requiresUser = await User.findByIdAndUpdate(userId,{name:'noname'},{ new:true}).exec()

Mongoose相关问题