在Mongoose中，可以通过定义一个schema来保存复杂的JSON数据。Schema是Mongoose中用来定义document的结构和数据类型的方式。当你需要保存嵌套的JSON对象时，可以在schema中使用嵌套的文档（subdocuments）或者Mixed类型。

### 使用嵌套文档(Subdocuments)

如果JSON结构是已知的，并且你想要在其中嵌套对象，你可以在schema中定义子文档。

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

// 子文档的schema
const childSchema = new Schema({
    name: String,
    age: Number
});

// 主文档的schema
const parentSchema = new Schema({
    children: [childSchema], // 子文档数组
    name: String
});

// 创建模型
const Parent = mongoose.model('Parent', parentSchema);

// 创建一个带有嵌套子文档的实例
const parent = new Parent({
    name: 'John Doe',
    children: [{
        name: 'Jane Doe',
        age: 10
    }, {
        name: 'Jack Doe',
        age: 8
    }]
});

// 保存实例
parent.save(function (err) {
    if (err) return handleError(err);
    // 已保存
});
```

### 使用Mixed类型

如果JSON数据结构不固定或非常复杂，你可以使用`Schema.Types.Mixed`这个类型来保存任意类型的数据。

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

// 使用Mixed类型来定义schema
const anySchema = new Schema({
    any: Schema.Types.Mixed
});

// 创建模型
const AnyModel = mongoose.model('Any', anySchema);

// 创建一个包含复杂JSON数据的实例
const anyData = new AnyModel({
    any: {
        someField: 'value',
        nested: {
            complex: ['data', { can: 'be' }, 'anything'],
            you: 'like'
        }
    }
});

// 保存实例
anyData.save(function (err) {
    if (err) return handleError(err);
    // 已保存
});
```

使用`Mixed`类型时需要注意的是，Mongoose不会自动追踪这种类型的变化，所以如果你更改了Mixed类型字段中的数据，需要手动调用`.markModified(path)`方法来告诉Mongoose这个字段被修改了。

```javascript
anyData.any.nested.complex.push('new data');
anyData.markModified('any');
anyData.save(function (err) {
    if (err) return handleError(err);
    // 已保存更新后的数据
});
```

### 总结

在Mongoose中保存复杂的JSON数据通常涉及定义一个准确反映数据结构的schema。你可以通过使用嵌套文档来保存已知结构的数据，或者使用Mixed类型来保存不固定或非常复杂的数据。记得对于Mixed类型的字段，在修改后需要调用`.markModified()`方法以确保正确保存。

On express 3 you can use directly res.json({foo:bar})

    res.json({ msgId: msg.fileName })
    

See the [documentation](http://expressjs.com/api.html#res.json)

I don't know if this is really any different, but rather than iterate over the query cursor, you could do something like this:

    query.exec(function (err, results){
      if (err) res.writeHead(500, err.message)
      else if (!results.length) res.writeHead(404);
      else {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.write(JSON.stringify(results.map(function (msg){ return {msgId: msg.fileName}; })));
      }
      res.end();
    });

**\[Edit\]** After reviewing the Mongoose documentation, it looks like you can send each query result as a separate chunk; the web server uses [chunked transfer encoding](http://en.wikipedia.org/wiki/Chunked_transfer_encoding) [by default](http://nodejs.org/docs/latest/api/http.html#response.write) so all you have to do is wrap an array around the items to make it a valid JSON object.

Roughly (untested):

    app.get('/users/:email/messages/unread', function(req, res, next) {
      var firstItem=true, query=MessageInfo.find(/*...*/);
      res.writeHead(200, {'Content-Type': 'application/json'});
      query.each(function(docs) {
        // Start the JSON array or separate the next element.
        res.write(firstItem ? (firstItem=false,'[') : ',');
        res.write(JSON.stringify({ msgId: msg.fileName }));
      });
      res.end(']'); // End the JSON array and response.
    });
    

Alternatively, as you mention, you can simply send the array contents as-is. In this case [the response body will be buffered](http://nodejs.org/docs/latest/api/http.html#response.write) and sent immediately, which may consume a large amount of additional memory (above what is required to store the results themselves) for large result sets. For example:

    // ...
    var query = MessageInfo.find(/*...*/);
    res.writeHead(200, {'Content-Type': 'application/json'});
    res.end(JSON.stringify(query.map(function(x){ return x.fileName })));

How to return a complex json response with node js

在Mongoose中，`_id` 是一个文档的默认主键，而 `id` 是 `ObjectId` 类型的 `_id` 字段的虚拟访问器。

详细解释如下：

### `_id`

- 每个在MongoDB中创建的文档都有一个唯一的 `_id` 字段，这个字段在文档创建时自动生成。
- `_id` 字段默认是一个 `ObjectId` 对象，它是一个十二字节的唯一值，MongoDB使用这个字段作为主键。
- `ObjectId` 包含了时间戳（文档创建的时间），机器标识码，MongoDB服务进程id和序列号，这些可以保证在分布式系统中 `_id` 的唯一性。

### `id`

- `id` 是Mongoose为 `_id` 字段提供的虚拟属性，它其实就是 `_id` 的字符串表示形式。
- 访问 `id` 属性时，Mongoose会调用 `_id` 字段的 `.toString()` 方法，将其转换为24字符的十六进制字符串。
- 因为 `id` 是虚拟生成的，所以它并不实际存在于MongoDB数据库中，仅仅是Mongoose层面给予的便利。

### 使用场景

当你需要在程序中使用文档的主键时，直接使用 `_id` 字段就可以了。如果你需要将文档的主键以字符串形式发送到前端或者作为URL的一部分，比如在RESTful API中通常使用字符串格式的ID，那么就可以使用 `id` 属性。

### 示例

假设你有一个用户文档，其 `_id` 字段是 `ObjectId('507f191e810c19729de860ea')`，你可以这样访问该文档的ID：

```javascript
const user = await User.findById('507f191e810c19729de860ea');
console.log(user._id); // 打印 ObjectId('507f191e810c19729de860ea')
console.log(user.id);  // 打印 '507f191e810c19729de860ea' 的字符串形式
```

在上述代码中，`user._id` 返回的是 `ObjectId` 对象，而 `user.id` 返回的是相应的字符串形式。当你需要将这个ID以纯文本格式传递或者展示时，`id` 属性就非常有用了。

总之，`_id` 是数据库中文档的实际主键，而 `id` 是一个方便我们使用的虚拟属性。

From the [documentation](http://mongoosejs.com/docs/guide.html#id):

> Mongoose assigns each of your schemas an id virtual getter by default which returns the documents \_id field cast to a string, or in the case of ObjectIds, its hexString.

So, basically, the `id` getter returns a string representation of the document's `_id` (which is added to all MongoDB documents by default and have a default type of `ObjectId`).

Regarding what's better for referencing, that depends entirely on the context (i.e., do you want an `ObjectId` or a `string`). For example, if comparing `id`'s, the string is probably better, as `ObjectId`'s won't pass an equality test unless they are the same instance (regardless of what value they represent).

What is the difference between id and id in mongoose?

在 Mongoose 中，如果您想要从查询结果中排除特定的字段，您可以通过在查询的 `select` 方法中设置字段名前加上 `-` 符号来实现。这告诉 Mongoose 在查询结果中排除这些字段。

例如，假设我们有一个名为 `User` 的模型，它包含多个字段，例如 `name`、`email` 和 `password`。如果我们想要查询所有用户但不想在结果中包含 `password` 字段，我们可以这样编写查询：

```javascript
User.find().select('-password').exec((err, users) => {
  if (err) throw err;
  // 处理不包含密码的用户数据
  console.log(users);
});
```

在上面的例子中，`.find()` 方法会检索集合中所有的文档，`.select('-password')` 会排除 `password` 字段。如果要排除多个字段，可以连续添加排除的字段，如 `.select('-password -someOtherField')`。

另一种方式是在查询对象中直接使用字段选择符：

```javascript
User.find({}, '-password', (err, users) => {
  if (err) throw err;
  // 处理不包含密码的用户数据
  console.log(users);
});
```

在这个例子中，第二个参数是一个字符串，指定了需要排除的字段（在字段名称前加上 `-`）。

还可以在查询对象中以对象的形式指定要排除的字段：

```javascript
User.find({}, { password: 0 }, (err, users) => {
  if (err) throw err;
  // 处理不包含密码的用户数据
  console.log(users);
});
```

在这种情况下，我们通过 `{ password: 0 }` 对象指定不要包括 `password` 字段，其中 `0` 表示排除该字段。

以上都是在查询时排除一个特定字段的方法，这样可以确保敏感信息不会被发送到客户端，也可以提升性能，因为少传输了数据。

Use [`query.select`](http://mongoosejs.com/docs/api.html#query_Query-select) for field selection in the current (3.x) Mongoose builds.

Prefix a field name you want to exclude with a `-`; so in your case:

    Query.select('-Image');
    

Quick aside: in JavaScript, variables starting with a capital letter should be reserved for constructor functions. So consider renaming `Query` as `query` in your code.

I don't know where you read about that .exclude function, because I can't find it in any documentation.

But you can exclude fields by using the second parameter of the find method.

Here is an example from [the official documentation](http://docs.mongodb.org/manual/core/read-operations/):

    db.inventory.find( { type: 'food' }, { type:0 } )
    

> This operation returns all documents where the value of the type field is food, but does not include the type field in the output.

Model.findOne({ _id: Your Id}, { password: 0, name: 0 }, function(err, user){
      // put your code
    });
    

this code worked in my project. Thanks!! have a nice day.

You could do this

    const products = await Product.find().select(['-image'])

You can do it like this

    const products = await Product.find().select({
      "image": 0
    });

How to exclude one particular field from a collection in mongoose?

在 Mongoose 中，`populate` 和 `aggregate` 都是处理 MongoDB 文档引用的强大工具。`populate` 用于自动替换文档中的指定路径，用其引用的文档。`aggregate` 是一个更强大的工具，它可以执行复杂的数据处理，如分组(grouping)、排序(sorting)、计算字段等。

直到一段时间以前，`populate` 和 `aggregate` 无法直接结合使用。然而，最新版本的 Mongoose 允许在 `aggregate` 管道中使用 `$lookup` 操作符实现功能类似于 `populate` 的效果。这意味着你现在可以在同一个查询中使用 `aggregate` 的强大功能并进行“填充”。

以下是一个使用 Mongoose 中 `aggregate` 和类似 `populate` 功能的示例：

假设我们有两个集合，`authors` 和 `books`。每本 `book` 文档都有一个字段 `author`，其中包含其对应 `author` 文档的引用。

Mongoose 的 `aggregate` 方法允许你向管道添加多个阶段，而 `$lookup` 阶段就可以用于实现类似 `populate` 的功能：

```javascript
const Book = mongoose.model('Book');

Book.aggregate([
  {
    $lookup: {
      from: 'authors', // 这是在数据库中 authors 集合的名称
      localField: 'author', // book 中指向 author 的字段
      foreignField: '_id', // author 集合中的 _id 字段
      as: 'authorDetails' // 添加到结果文档中的字段名称，其中包含所有匹配的文档
    }
  },
  {
    $unwind: '$authorDetails' // 展开 authorDetails 数组，使其成为单个文档字段
  },
  // 其他可能的 aggregation stages，比如 $match, $group, $sort 等
  // ...
]).exec((err, books) => {
  if (err) throw err;
  console.log(books);
});
```

在这个例子中，`$lookup` 用来联结 `books` 集合和 `authors` 集合。`localField` 和 `foreignField` 分别指定了本地和外部的匹配字段。`as` 字段指定了查找结果的输出字段。通过这种方式，`aggregate` 查询也可以返回带有关联数据的文档，类似于 `populate` 的行为。

需要注意的是，`$lookup` 只能用于 MongoDB 3.2 及以上版本，并且它要求关联的集合必须在同一个数据库中。而且，`$unwind` 阶段是可选的，只有当你知道每个匹配项只有一个文档时才需要它。（在一对多的关系中，`$unwind` 会产生多个文档。）

总结一下，通过结合使用 `aggregate` 和 `$lookup`，你可以实现复杂的查询，同时“填充”来自其他集合的数据。这种方法比传统的 `populate` 提供了更高的灵活性和控制能力。

With the latest version of mongoose (mongoose >= 3.6), you _can_ but it requires a second query, and using populate differently. After your aggregation, do this:

    Patients.populate(result, {path: "patient"}, callback);
    

See more at the [Mongoose API](http://mongoosejs.com/docs/api.html#model_Model.populate) and the [Mongoose docs](http://mongoosejs.com/docs/populate.html#populate_multiple_documents).

Edit: Looks like there's a new way to do it in the latest Mongoose API (see the above answer here: [https://stackoverflow.com/a/23142503/293492](https://stackoverflow.com/a/23142503/293492))

Old answer below
----------------

You can use $lookup which is similar to populate.

In an unrelated example, I use $match to query for records and $lookup to populate a foreign model as a sub-property of these records:

      Invite.aggregate(
          { $match: {interview: req.params.interview}},
          { $lookup: {from: 'users', localField: 'email', foreignField: 'email', as: 'user'} }
        ).exec( function (err, invites) {
          if (err) {
            next(err);
          }
    
          res.json(invites);
        }
      );

You have to do it in two, not in one statement.

In **_async await_** scenario, make sure **await** until populate.

    const appointments = await Appointments.aggregate([...]);
    
    await Patients.populate(appointments, {path: "patient"});
    
    return appointments;

Run code snippetHide results

Expand snippet

or (if you want to limit)

    await Patients.populate(appointments, {path: "patient",  select:  {_id: 1, fullname: 1}});

Run code snippetHide results

Expand snippet

You can do it in one query like this:

    Appointments.aggregate([{
            $group: {
                _id: '$date',
                patients: {
                    $push: '$patient'
                }
            }
        },
        {
            $project: {
                date: '$_id',
                patients: 1,
                _id: 0
            }
        },
        {
            $lookup: {
                from: "patients",
                localField: "patient",
                foreignField: "_id",
                as: "patient_doc"
            }
        }
    ])
    

populate basically uses $lookup under the hood. in this case no need for a second query. for more details check [MongoDB aggregation lookup](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/)

**Perform a Join with $lookup**

A collection orders contains the following documents:

    { "_id" : 1, "item" : "abc", "price" : 12, "quantity" : 2 }
    { "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1 }
    { "_id" : 3  }
    

Another collection inventory contains the following documents:

    { "_id" : 1, "sku" : "abc", description: "product 1", "instock" : 120 }
    { "_id" : 2, "sku" : "def", description: "product 2", "instock" : 80 }
    { "_id" : 3, "sku" : "ijk", description: "product 3", "instock" : 60 }
    { "_id" : 4, "sku" : "jkl", description: "product 4", "instock" : 70 }
    { "_id" : 5, "sku": null, description: "Incomplete" }
    { "_id" : 6 }
    

The following aggregation operation on the orders collection joins the documents from orders with the documents from the inventory collection using the fields item from the orders collection and the sku field from the inventory collection:

    db.orders.aggregate([
        {
          $lookup:
            {
              from: "inventory",
              localField: "item",
              foreignField: "sku",
              as: "inventory_docs"
            }
       }
    ])
    

The operation returns the following documents:

    {
      "_id" : 1,
       "item" : "abc",
      "price" : 12,
      "quantity" : 2,
      "inventory_docs" : [
        { "_id" : 1, "sku" : "abc", description: "product 1", "instock" : 120       }
      ]
     }
    {
      "_id" : 2,
      "item" : "jkl",
      "price" : 20,
      "quantity" : 1,
      "inventory_docs" : [
        { "_id" : 4, "sku" : "jkl", "description" : "product 4", "instock" : 70 }
      ]
    }
    {
      "_id" : 3,
      "inventory_docs" : [
        { "_id" : 5, "sku" : null, "description" : "Incomplete" },
        { "_id" : 6 }
      ]
    }
    

[Reference $lookup](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/)

How to use populate and aggregate in same statement?

在Mongoose中，如果你想查询独特不重复的值，可以使用`distinct`方法。这个方法会在特定的文档集合中，对指定字段进行去重处理，并返回所有独特不重复的值。

以下是使用`distinct`方法的一个例子：

假设你有一个名为`User`的模型，模型中有一个字段叫`email`，你想要查询所有不重复的电子邮件地址。

```javascript
const uniqueEmails = await User.distinct('email');
console.log(uniqueEmails);
```

这段代码会返回一个包含所有唯一电子邮件地址的数组。

如果你想对查询结果进一步筛选，例如只查询那些账户已经验证的用户的唯一电子邮件地址，可以在`distinct`方法中添加查询条件：

```javascript
const uniqueVerifiedEmails = await User.distinct('email', { isVerified: true });
console.log(uniqueVerifiedEmails);
```

在这个例子中，`distinct`方法的第二个参数 `{ isVerified: true }` 表示一个查询条件，它将返回字段`email`的不重复值，但只限于那些`isVerified`字段为`true`的文档。

使用`distinct`方法是在处理大数据集合时，以高效的方式查询独特值的一个很好的选择。但是请注意，性能会受到数据库索引配置的影响，因此，为了提高查询效率，相应字段上应该有合适的索引。

Just to give an update for Mongoose 3.x:

    MyModel.find().distinct('_id', function(error, ids) {
        // ids is an array of all ObjectIds
    });

In my program, this code works.

    Person.collection.distinct("born_in_city", function(error, results){
      console.log(results);
    });
    

by node.js v0.4.7, mongoose 1.3.3

const findBornCity = async() => {
        const bornCity = await Person.find().distinct("born_in_city")
        return bornCity
    }

I read through the source code and the node-mongodb-native driver is what powers the class. So on the connection object. So after you have done mongoose.connect(mongodb://), you can give this a shot.

    if(mongoose.connections.length > 0) {
      var nativeconn = mongoose.connections[0].conn;
      nativeconn.person.distinct('born_in_city', function(error, results){
    
      });
    }

Model.distinct("field")
       .exec()
       .then(result => {
          console.log(result);
       });
    

[https://www.cltechhome.com/2023/02/how-do-i-query-for-distinct-values-in.html](https://www.cltechhome.com/2023/02/how-do-i-query-for-distinct-values-in.html)

How do i query for distinct values in mongoose

Mongoose 中的 `Schema` 和 `Model` 是 MongoDB 数据库操作的两个非常重要的概念，它们在设计和操作数据库时扮演着不同的角色。

### Schema

`Schema` 是用于定义 MongoDB 集合中文档的结构的一种方式。它是一个对象，描述了数据的形状和类型，可以理解为数据的蓝图或者模板。通过 `Schema`，我们可以非常详细地指定文档中应该有哪些字段、字段类型是什么、是否必须、默认值是多少、验证规则等信息。

例如，如果我们有一个用户的集合，我们可能会定义一个这样的 `Schema`：

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

const userSchema = new mongoose.Schema({
  username: {
    type: String,
    required: true
  },
  password: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
```

在这个例子中，`userSchema` 定义了用户应该有 `username`、`password`、`email` 以及 `createdAt` 这些字段，它们的类型分别是 `String` 和 `Date`，并且除了 `createdAt` 有默认值外，其他的都是必填的。

### Model

`Model` 是基于 `Schema` 编译而成的构造函数，或者说类，它的实例就代表了数据库中的一个个文档。通过 `Model`，我们可以对数据库进行实际的 CRUD 操作（创建、读取、更新、删除）。

继续上面的例子，我们会这样创建一个 `Model`：

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

这里，我们创建了一个叫做 `User` 的 `Model`，它关联到了 `userSchema`。这意味着我们现在可以创建新用户、查询用户、更新用户、删除用户等：

```javascript
// 创建新用户
const newUser = new User({
  username: 'johndoe',
  password: '123456',
  email: 'johndoe@example.com'
});

newUser.save((err, savedUser) => {
  if (err) throw err;
  // savedUser 是存入数据库的用户文档
});

// 查询所有用户
User.find({}, (err, users) => {
  if (err) throw err;
  // users 是一个包含所有用户文档的数组
});
```

### 为什么既有 Schema 又有 Model？

`Schema` 和 `Model` 之所以分开，是因为它们各自承担了不同的职责。`Schema` 负责定义数据的结构和规则，而 `Model` 则是一个提供与数据库交互能力的接口。

将这两者分开，使得 Mongoose 的设计更加灵活和模块化。你可以在一个地方定义你的数据结构（`Schema`），然后在需要的地方创建一个或多个 `Model` 来处理数据。这种分离也便于维护和扩展，因为数据结构可能会频繁变化，而分开后，我们可以仅仅修改 `Schema` 而不需要触及到使用它的 `Model`。

此外，Mongoose 还允许我们在 `Schema` 中定义实例方法、静态方法和虚拟属性，这样我们可以在 `Model` 的实例上调用这些方法，从而让数据操作更加方便和高效。

**EDIT:** Although this has been useful for many people, as mentioned in the comments it answers the "how" rather than the why. Thankfully, the why of the question has been answered elsewhere also, with [this answer to another question](https://stackoverflow.com/a/22950402/1148648). This has been linked in the comments for some time but I realise that many may not get that far when reading.

Often the easiest way to answer this type of question is with an example. In this case, someone has already done it for me :)

Take a look here:

[http://rawberg.com/blog/nodejs/mongoose-orm-nested-models/](http://rawberg.com/blog/nodejs/mongoose-orm-nested-models/)

**EDIT:** The original post (as mentioned in the comments) seems to no longer exist, so I am reproducing it below. Should it ever return, or if it has just moved, please let me know.

It gives a decent description of using schemas within models in mongoose and why you would want to do it, and also shows you how to push tasks via the model while the schema is all about the structure etc.

**Original Post:**

Let’s start with a simple example of embedding a schema inside a model.

    var TaskSchema = new Schema({
        name: String,
        priority: Number
    });
     
    TaskSchema.virtual('nameandpriority')
        .get( function () {
            return this.name + '(' + this.priority + ')';
        });
     
    TaskSchema.method('isHighPriority', function() {
        if(this.priority === 1) {
            return true;
        } else {
            return false;
        }
    }); 
     
    var ListSchema = new Schema({
        name: String,
        tasks: [TaskSchema]
    });
     
    mongoose.model('List', ListSchema);
     
    var List = mongoose.model('List');
     
    var sampleList = new List({name:'Sample List'});
    

I created a new `TaskSchema` object with basic info a task might have. A Mongoose [virtual attribute](http://mongoosejs.com/docs/virtuals.html) is setup to conveniently combine the name and priority of the Task. I only specified a getter here but virtual setters are supported as well.

I also defined a simple task method called `isHighPriority` to demonstrate how methods work with this setup.

In the `ListSchema` definition you’ll notice how the `tasks` key is configured to hold an array of `TaskSchema` objects. The `task` key will become an instance of [`DocumentArray`](https://github.com/Automattic/mongoose/blob/master/lib/types/DocumentArray/index.js) which provides special methods for dealing with embedded Mongo documents.

For now I only passed the `ListSchema` object into `mongoose.model` and left the `TaskSchema` out. Technically it's not necessary to turn the `TaskSchema` into a formal model since we won’t be saving it in it’s own collection. Later on I’ll show you how it doesn’t harm anything if you do and it can help to organize all your models in the same way especially when they start spanning multiple files.

With the `List` model setup let’s add a couple tasks to it and save them to Mongo.

    var List = mongoose.model('List');
    var sampleList = new List({name:'Sample List'});
     
    sampleList.tasks.push(
        {name:'task one', priority:1}, 
        {name:'task two', priority:5}
    );
     
    sampleList.save(function(err) {
        if (err) {
            console.log('error adding new list');
            console.log(err);
        } else {
            console.log('new list successfully saved'); 
        }
    });
    

The tasks attribute on the instance of our `List` model (`sampleList`) works like a regular JavaScript array and we can add new tasks to it using push. The important thing to notice is the `tasks` are added as regular JavaScript objects. It’s a subtle distinction that may not be immediately intuitive.

You can verify from the Mongo shell that the new list and tasks were saved to mongo.

    db.lists.find()
    { "tasks" : [
        {
            "_id" : ObjectId("4dd1cbeed77909f507000002"),
            "priority" : 1,
            "name" : "task one"
        },
        {
            "_id" : ObjectId("4dd1cbeed77909f507000003"),
            "priority" : 5,
            "name" : "task two"
        }
    ], "_id" : ObjectId("4dd1cbeed77909f507000001"), "name" : "Sample List" }
    

Now we can use the `ObjectId` to pull up the `Sample List` and iterate through its tasks.

    List.findById('4dd1cbeed77909f507000001', function(err, list) {
        console.log(list.name + ' retrieved');
        list.tasks.forEach(function(task, index, array) {
            console.log(task.name);
            console.log(task.nameandpriority);
            console.log(task.isHighPriority());
        });
    });
    

If you run that last bit of code you’ll get an error saying the embedded document doesn’t have a method `isHighPriority`. In the current version of Mongoose you can’t access methods on embedded schemas directly. There’s an [open ticket](https://github.com/LearnBoost/mongoose/issues/249) to fix it and after posing the question to the Mongoose Google Group, manimal45 posted a helpful work-around to use for now.

    List.findById('4dd1cbeed77909f507000001', function(err, list) {
        console.log(list.name + ' retrieved');
        list.tasks.forEach(function(task, index, array) {
            console.log(task.name);
            console.log(task.nameandpriority);
            console.log(task._schema.methods.isHighPriority.apply(task));
        });
    });
    

If you run that code you should see the following output on the command line.

    Sample List retrieved
    task one
    task one (1)
    true
    task two
    task two (5)
    false
    

With that work-around in mind let’s turn the `TaskSchema` into a Mongoose model.

    mongoose.model('Task', TaskSchema);
     
    var Task = mongoose.model('Task');
     
    var ListSchema = new Schema({
        name: String,
        tasks: [Task.schema]
    });
     
    mongoose.model('List', ListSchema);
     
    var List = mongoose.model('List');
    

The `TaskSchema` definition is the same as before so I left it out. Once its turned into a model we can still access it’s underlying Schema object using dot notation.

Let’s create a new list and embed two Task model instances within it.

    var demoList = new List({name:'Demo List'});
     
    var taskThree = new Task({name:'task three', priority:10});
    var taskFour = new Task({name:'task four', priority:11});
     
    demoList.tasks.push(taskThree.toObject(), taskFour.toObject());
     
    demoList.save(function(err) {
        if (err) {
            console.log('error adding new list');
            console.log(err);
        } else {
            console.log('new list successfully saved'); 
        }
    });
    

As we’re embedding the Task model instances into the List we’re calling `toObject` on them to convert their data into plain JavaScript objects that the `List.tasks` `DocumentArray` is expecting. When you save model instances this way your embedded documents will contain `ObjectIds`.

The complete code example is [available as a gist](https://gist.github.com/976074). Hopefully these work-arounds help smooth things over as Mongoose continues to develop. I’m still pretty new to Mongoose and MongoDB so please feel free to share better solutions and tips in the comments. Happy data modeling!

**Schema** is an object that defines the structure of any documents that will be stored in your MongoDB collection; it enables you to define types and validators for all of your data items.

**Model** is an object that gives you easy access to a named collection, allowing you to query the collection and use the Schema to validate any documents you save to that collection. It is created by combining a Schema, a Connection, and a collection name.

Originally phrased by Valeri Karpov, [MongoDB Blog](http://blog.mongodb.org/post/52299826008/the-mean-stack-mistakes-youre-probably-making)

I don't think the accepted answer actually answers the question that was posed. The answer doesn't explain _why_ Mongoose has decided to require a developer to provide both a Schema and a Model variable. An example of a framework where they have eliminated the need for the _developer_ to define the data schema is django--a developer writes up their models in the models.py file, and leaves it to the framework to manage the schema. The first reason that comes to mind for why they do this, given my experience with django, is ease-of-use. Perhaps more importantly is the DRY (don't repeat yourself) principle--you don't have to remember to update the schema when you change the model--django will do it for you! Rails also manages the schema of the data for you--a developer doesn't edit the schema directly, but changes it by defining migrations that manipulate the schema.

One reason I could understand that Mongoose would separate the schema and the model is instances where you would want to build a model from two schemas. Such a scenario might introduce more complexity than is worth managing--if you have two schemas that are managed by one model, why aren't they one schema?

Perhaps the original question is more a relic of the traditional relational database system. In world NoSQL/Mongo world, perhaps the schema is a little more flexible than MySQL/PostgreSQL, and thus changing the schema is more common practice.

**To understand why? you have to understand what actually is Mongoose?**

Well, the mongoose is an object data modeling library for MongoDB and Node JS, providing a higher level of abstraction. So it's a bit like the relationship between Express and Node, so Express is a layer of abstraction over regular Node, while Mongoose is a layer of abstraction over the regular MongoDB driver.

An object data modeling library is just a way for us to write Javascript code that will then interact with a database. So we could just use a regular MongoDB driver to access our database, it would work just fine.

But instead we use Mongoose because it gives us a lot more functionality out of the box, allowing for faster and simpler development of our applications.

So, some of the features Mongoose gives us schemas to model our data and relationship, easy data validation, a simple query API, middleware, and much more.

In Mongoose, a schema is where we model our data, where we describe the structure of the data, default values, and validation, then we take that schema and create a model out of it, a model is basically a wrapper around the schema, which allows us to actually interface with the database in order to create, delete, update, and read documents.

[![enter image description here](https://i.stack.imgur.com/MgZ2F.png)](https://i.stack.imgur.com/MgZ2F.png)

Let's create a model from a schema.

    const tourSchema = new mongoose.Schema({
      name: {
        type: String,
        required: [true, 'A tour must have a name'],
        unique: true,
      },
      rating: {
        type: Number,
        default: 4.5,
      },
      price: {
        type: Number,
        required: [true, 'A tour must have a price'],
      },
    });
    //tour model
    const Tour = mongoose.model('Tour', tourSchema);
    

According to convetion first letter of a model name must be capitalized.

Let's create instance of our model that we created using mongoose and schema. also, interact with our database.

    const testTour = new Tour({ // instance of our model
      name: 'The Forest Hiker',
      rating: 4.7,
      price: 497,
    });
     // saving testTour document into database
    testTour
      .save()
      .then((doc) => {
        console.log(doc);
      })
      .catch((err) => {
        console.log(err);
      });
    

So having both schama and modle mongoose makes our life easier.

Why does mongoose have both schemas and models

在 Mongoose 中，每个保存到 MongoDB 的文档都会自动获得一个 `_id` 属性，它是一个 ObjectId 类型的默认属性。当您使用 Mongoose 的模型创建并保存一个新的文档时，Mongoose 在内部会调用 MongoDB 的 `insert` 操作，该操作会生成一个新的 ObjectId。这个 `_id` 是唯一的，并且会被自动添加到您的文档中。

保存文档后获取文档的 `_id`（即 ObjectId）非常直接。在您调用 `.save()` 方法并通过回调或者 Promise 获取到保存操作的结果时，您可以直接访问文档的 `_id` 属性。

以下是一个使用 Promise 的例子：

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

// 定义一个简单的模式
const mySchema = new Schema({
  name: String
});

// 创建模型
const MyModel = mongoose.model('MyModel', mySchema);

// 创建一个文档实例
const myDocument = new MyModel({ name: 'John Doe' });

// 保存文档
myDocument.save().then((savedDocument) => {
  // 文档保存后，我们可以直接获取 _id
  console.log('Document saved with _id:', savedDocument._id);
}).catch((error) => {
  console.error('Error saving document:', error);
});
```

在上述例子中，当 `.save()` 方法成功执行后，它将返回一个包含已保存文档的 Promise 对象。在这个 Promise 的`.then` 部分，我们可以通过 `savedDocument._id` 来访问这个新创建的 ObjectId。如果保存操作失败，则会进入 `.catch` 部分，我们可以处理错误信息。

如果您是在使用 async/await 语法，那么代码会是这样的：

```javascript
// 使用 async/await 保存文档
async function saveDocument() {
  try {
    const savedDocument = await myDocument.save();
    console.log('Document saved with _id:', savedDocument._id);
  } catch (error) {
    console.error('Error saving document:', error);
  }
}

// 执行保存操作
saveDocument();
```

在这个 async/await 的例子中，我们在一个异步函数 `saveDocument` 中使用了 `await` 关键字来等待 `myDocument.save()` 的执行结果。如果执行成功，我们可以直接通过 `savedDocument._id` 访问到 `_id` 属性。如果执行时遇到错误，则会进入 `catch` 块，在这里我们可以处理错误。

This just worked for me:

    var mongoose = require('mongoose'),
          Schema = mongoose.Schema;
    
    mongoose.connect('mongodb://localhost/lol', function(err) {
        if (err) { console.log(err) }
    });
    
    var ChatSchema = new Schema({
        name: String
    });
    
    mongoose.model('Chat', ChatSchema);
    
    var Chat = mongoose.model('Chat');
    
    var n = new Chat();
    n.name = "chat room";
    n.save(function(err,room) {
       console.log(room.id);
    });
    
    $ node test.js
    4e3444818cde747f02000001
    $
    

I'm on mongoose 1.7.2 and this works just fine, just ran it again to be sure.

Mongo sends the complete document as a callbackobject so you can simply get it from there only.

for example

    n.save(function(err,room){
      var newRoomId = room._id;
      });

You can manually generate the \_id then you don't have to worry about pulling it back out later.

    var mongoose = require('mongoose');
    var myId = mongoose.Types.ObjectId();
    
    // then set it manually when you create your object
    
    _id: myId
    
    // then use the variable wherever

You can get the object id in Mongoose right after creating a new object instance without having to save it to the database.

I'm using this code work in mongoose 4. You can try it in other versions.

    var n = new Chat();
    var _id = n._id;
    

or

    n.save((function (_id) {
      return function () {
        console.log(_id);
        // your save callback code in here
      };
    })(n._id));

Other answers have mentioned adding a callback, I prefer to use .then()

    n.name = "chat room";
    n.save()
    .then(chatRoom => console.log(chatRoom._id));
    

example from [the docs](https://mongoosejs.com/docs/promises.html):.

    var gnr = new Band({
      name: "Guns N' Roses",
      members: ['Axl', 'Slash']
    });
    
    var promise = gnr.save();
    assert.ok(promise instanceof Promise);
    
    promise.then(function (doc) {
      assert.equal(doc.name, "Guns N' Roses");
    });

How do i get the objectid after i save an object in mongoose

在Mongoose中，每个模型的文档都有一个`_id`属性，这个属性默认是一个`ObjectId`类型。`ObjectId`是MongoDB中的一种数据类型，通常用于唯一标识文档。

如果你需要将`ObjectId`转换为字符串，有几种方法可以做到：

1. 使用`toString()`方法：
   每个`ObjectId`对象都有一个`toString()`方法，可以调用它来将`ObjectId`转换为24位的十六进制字符串。

   ```javascript
   const idAsString = myDocument._id.toString();
   ```

2. 使用`String`构造函数：
   你也可以直接用`String`构造函数将`ObjectId`转换为字符串。

   ```javascript
   const idAsString = String(myDocument._id);
   ```

3. 使用 ES6 模板字符串：
   ES6 引入了模板字符串，你可以简单地将`ObjectId`嵌入到模板字符串中，它将自动调用`ObjectId`的`toString()`方法。

   ```javascript
   const idAsString = `${myDocument._id}`;
   ```

4. 在查询时直接转换：
   如果你在查询时就想获取字符串形式的`_id`，可以使用Mongoose的虚拟属性功能，将`_id`字段设置为虚拟的字符串类型字段。

   ```javascript
   schema.virtual('id').get(function(){
     return this._id.toHexString();
   });
   
   // 然后可以这样获取字符串形式的_id
   const idAsString = myDocument.id;
   ```

以上方法可以根据需要在不同场合下使用。例如，如果你正在编写一个API并且需要在JSON响应中返回`_id`，由于`ObjectId`不是一个标准的JSON数据类型，你可能需要将其转换为字符串。如果你在Mongoose中使用虚拟属性，你还可以让Mongoose在将文档转换为JSON时自动执行这种转换。

Try this:

    user._id.toString()
    

A **MongoDB ObjectId** is a 12-byte UUID can be used as a HEX string representation with 24 chars in length. You need to convert it to string to show it in `console` using `console.log`.

So, you have to do this:

    console.log(user._id.toString());

Take the underscore out and try again:

    console.log(user.id)
    

Also, the value returned from id is already a string, as you can see [here](https://github.com/LearnBoost/mongoose/issues/548#issuecomment-2245903).

I'm using mongojs, and I have this example:

    db.users.findOne({'_id': db.ObjectId(user_id)  }, function(err, user) {
       if(err == null && user != null){
          user._id.toHexString(); // I convert the objectId Using toHexString function.
       }
    })

try this:

    objectId.str;
    

see [doc](http://docs.mongodb.org/manual/reference/object-id/).

If you're using Mongoose, the only way to be sure to have the id as an hex String seems to be:

    object._id ? object._id.toHexString():object.toHexString();
    

This is because object.\_id exists only if the object is populated, if not the object is an ObjectId

How to convert objectid to string in mongoose?

在Mongoose中，如果想要同时保存多个文档，可以使用`Model.insertMany()`方法。这个方法接受一个数组作为参数，数组中包含了要创建的多个文档的数据。使用`insertMany`不仅可以减少对数据库的请求次数，而且还能提高数据插入的效率。

下面是一个使用`Model.insertMany()`方法的例子，这里假设我们有一个名为`User`的模型，代表用户信息的文档结构。

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

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

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

// 准备要插入的用户数据
const users = [
  { name: 'Alice', age: 25, email: 'alice@example.com' },
  { name: 'Bob', age: 30, email: 'bob@example.com' },
  { name: 'Carol', age: 22, email: 'carol@example.com' }
];

// 使用insertMany方法插入多个文档
User.insertMany(users)
  .then(docs => {
    console.log('Inserted documents:', docs);
  })
  .catch(err => {
    console.error('Error inserting documents:', err);
  });
```

在这个例子中，我们首先定义了一个用户的Schema和对应的模型。然后创建了一个包含三个用户信息的数组。使用`User.insertMany()`方法，我们可以一次性将这三个用户信息作为文档插入到数据库中。这个方法返回的是一个Promise，它会在所有文档都成功插入后解析，并提供插入的文档作为参数。如果在插入过程中出现错误，Promise会被拒绝，并返回错误信息。

这种操作在需要批量导入数据时非常有用，比如在初始化数据库或者处理批量注册用户的场景。

Mongoose does now support passing multiple document structures to [Model.create](http://mongoosejs.com/docs/api.html#model_Model-create). To quote their API example, it supports being passed either an array or a varargs list of objects with a callback at the end:

    Candy.create({ type: 'jelly bean' }, { type: 'snickers' }, function (err, jellybean, snickers) {
        if (err) // ...
    });
    

Or

    var array = [{ type: 'jelly bean' }, { type: 'snickers' }];
    Candy.create(array, function (err, jellybean, snickers) {
        if (err) // ...
    });
    

**Edit:** As many have noted, this does not perform a true bulk insert - it simply hides the complexity of calling `save` multiple times yourself. There are answers and comments below explaining how to use the actual Mongo driver to achieve a bulk insert in the interest of performance.

Mongoose 4.4 added a method called [`insertMany`](https://mongoosejs.com/docs/api.html#model_Model-insertMany)

> Shortcut for validating an array of documents and inserting them into MongoDB if they're all valid. This function is faster than .create() because it only sends one operation to the server, rather than one for each document.

Quoting vkarpov15 from issue [#723](https://github.com/Automattic/mongoose/issues/723#issuecomment-178866230):

> The tradeoffs are that insertMany() doesn't trigger pre-save hooks, but it should have better performance because it only makes 1 round-trip to the database rather than 1 for each document.

The method's signature is identical to `create`:

    Model.insertMany([ ... ], (err, docs) => {
      ...
    })
    

Or, with promises:

    Model.insertMany([ ... ]).then((docs) => {
      ...
    }).catch((err) => {
      ...
    })

Mongoose doesn't have bulk inserts implemented yet (see [issue #723](https://github.com/LearnBoost/mongoose/issues/723)).

Since you know the number of documents you're saving, you could write something like this:

    var total = docArray.length
      , result = []
    ;
    
    function saveAll(){
      var doc = docArray.pop();
    
      doc.save(function(err, saved){
        if (err) throw err;//handle error
    
        result.push(saved[0]);
    
        if (--total) saveAll();
        else // all saved here
      })
    }
    
    saveAll();
    

This, of course, is a stop-gap solution and I would recommend using some kind of flow-control library (I use [q](https://github.com/kriskowal/q) and it's awesome).

Bulk inserts in Mongoose can be done with .insert() unless you need to access middleware.

`Model.collection.insert(docs, options, callback)`

[https://github.com/christkv/node-mongodb-native/blob/master/lib/mongodb/collection.js#L71-91](https://github.com/christkv/node-mongodb-native/blob/master/lib/mongodb/collection.js#L71-91)

Use [async parallel](https://github.com/caolan/async#paralleltasks-callback) and your code will look like this:

      async.parallel([obj1.save, obj2.save, obj3.save], callback);
    

Since the convention is the same in Mongoose as in async (err, callback) you don't need to wrap them in your own callbacks, just add your save calls in an array and you will get a callback when all is finished.

If you use mapLimit you can control how many documents you want to save in parallel. In this example we save 10 documents in parallell until all items are successfully saved.

    async.mapLimit(myArray, 10, function(document, next){
      document.save(next);
    }, done);

How can i save multiple documents concurrently in mongoose?

MongoDB 使用 `_id` 作为默认的字段来存储文档的唯一标识符（primary key）。这个决策背后有几个原因：

1. **唯一性**: MongoDB 设计 `_id` 字段是为了确保集合中的每个文档都能够被唯一地标识。MongoDB 为每个新文档自动生成一个 ObjectId 类型的 `_id` 值，这个值在全局范围内是唯一的，这意味着即使在不同的服务器或集群上，两个文档不会有相同的 `_id`。

2. **一致性**: 使用 `_id` 作为所有文档的标准字段名，MongoDB 为开发人员提供了一致的接口来引用文档的主键。这种一致性简化了数据模型的设计，并且使得开发者可以编写更加通用的代码来处理不同的文档。

3. **索引**: 在 MongoDB 中，每个集合会自动对 `_id` 字段建立一个唯一索引。这样的设计保证了文档的快速查找和高效的数据完整性检查。如果没有这个默认的索引，开发人员需要手动为他们选择的主键字段建立索引，这会增加开发的复杂性。

例如，假设我们有一个用户集合（collection），其中包含了许多用户文档（document）。每个文档都会自动有一个 `_id` 字段，如下：

```json
{
  "_id": ObjectId("507f191e810c19729de860ea"),
  "name": "John Doe",
  "email": "john.doe@example.com"
}
```

即使开发者可以选择使用自定义的字段（比如 `id`）作为文档的标识符，但是为了保持一致性和利用 MongoDB 内建的索引，通常建议使用默认的 `_id` 字段。如果有特定的需要，开发者可以在应用层将 `_id` 映射到 `id` 或其他任何他们希望的字段上。这种情况下，开发者需要负责维护额外字段的唯一性和索引。

Given you're using Mongoose, you can use 'virtuals', which are essentially fake fields that Mongoose creates. They're not stored in the DB, they just get populated at run time:

    // Duplicate the ID field.
    Schema.virtual('id').get(function(){
        return this._id.toHexString();
    });
    
    // Ensure virtual fields are serialised.
    Schema.set('toJSON', {
        virtuals: true
    });
    

Any time toJSON is called on the Model you create from this Schema, it will include an 'id' field that matches the \_id field Mongo generates. Likewise you can set the behaviour for toObject in the same way.

See:

*   [http://mongoosejs.com/docs/api.html](http://mongoosejs.com/docs/api.html)
*   [http://mongoosejs.com/docs/guide.html#toJSON](http://mongoosejs.com/docs/guide.html#toJSON)
*   [http://mongoosejs.com/docs/guide.html#toObject](http://mongoosejs.com/docs/guide.html#toObject)

You can abstract this into a BaseSchema all your models then extend/invoke to keep the logic in one place. I wrote the above while creating an Ember/Node/Mongoose app, since Ember really prefers to have an 'id' field to work with.

As of Mongoose **v4.0** part of this functionality is **supported out of the box**. It's no longer required to manually add a virtual `id` field as explained by @Pascal Zajac.

> Mongoose assigns each of your schemas an id virtual getter by default which returns the documents \_id field cast to a string, or in the case of ObjectIds, its hexString. If you don't want an id getter added to your schema, you may disable it passing this option at schema construction time. [Source](http://mongoosejs.com/docs/guide.html#id)

However, to **export** this field to **JSON**, it's still required to **enable** serialization of virtual fields:

    Schema.set('toJSON', {
        virtuals: true
    });

I used this :

    schema.set('toJSON', {
      virtuals: true,
      versionKey:false,
      transform: function (doc, ret) {   delete ret._id  }
    });
    

I think it would be great if they automatically suppress \_id when virtuals is true.

I create a toClient() method on my models where I do this. It's also a good place to rename/remove other attributes you don't want to send to the client:

    Schema.method('toClient', function() {
        var obj = this.toObject();
    
        //Rename fields
        obj.id = obj._id;
        delete obj._id;
    
        return obj;
    });

Here is an alternative version of the answer provided by @user3087827. If you find that `schema.options.toJSON` is undefined then you can use:

    schema.set('toJSON', {
         transform: function (doc, ret, options) {
             ret.id = ret._id;
             delete ret._id;
             delete ret.__v;
         }
    });

Why mongodb output _id instead of id?

在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.

Which schematype in mongoose is best for a timestamp

在使用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 limit offset and count query

在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.

How to achieve oop in nodejs

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/)

How can you remove all documents from a collection with 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.

How to protect the password field in mongoose and it wont return in a query

在 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())

How do you use mongoose without defining a schema

在 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()` 方法）来进一步控制查询结果。

How do i limit the number of returned items

当您使用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!

How to access a preexisting collection with 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,_

How to get all count of 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()

所有问题