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


Mongoose

Mongoose 中的 `populate` 方法的作用是用于自动替换文档中的指定路径，将其从仅仅是一个外键（通常是 ObjectId）替换为实际的引用文档。这种操作在传统的 SQL 数据库中被称为“连接”（Join）操作。在 NoSQL 文档数据库中，如 MongoDB，这种操作并非由数据库引擎原生支持，而是通过 Mongoose 这样的 ODM（对象文档映射器）来模拟关系型数据库中的连接操作。

假设我们有两个 Mongoose 模型：一个是 `User`，一个是 `Post`。每个 `Post` 都是由某个 `User` 发布的。在 `Post` 模型中，我们可能会存储发布它的用户的 `ObjectId`。在不使用 `populate` 的情况下，当我们从数据库中查询 `Post` 文档时，我们只能看到用户的 `ObjectId`，我们不能直接获取到用户的详细信息。如果我们想要显示帖子旁边的用户信息，就需要进行两次查询：一次获取帖子，一次根据保存在帖子中的用户 `ObjectId` 获取用户信息。

使用 `populate`，我们可以在查询 `Post` 文档时告诉 Mongoose 自动地去获取并包含关联的 `User` 文档。举个例子：

```javascript
Post.find().populate('user').exec((err, posts) => {
  // 在这里，每个 `posts` 中的 'user' 字段现在不再是一个 ObjectId，
  // 而是一个完整的 `User` 文档。
});
```

这里的 `'user'` 是 `Post` 模型中定义的一个路径，它引用了 `User` 模型。`populate` 就是根据这个路径去找到对应的 `User` 文档，并将其包含在查询结果中。

使用 `populate` 可以大幅简化查询的逻辑，使得我们可以一次性获取到完整的数据，而不需要编写多个查询并手动组合它们的结果。然而，它也可能导致性能问题，因为每次 `populate` 都可能会导致额外的数据库查询，尤其是在有多个层级的引用时。因此，在使用 `populate` 时，需要注意性能和效率问题，有时可能需要考虑替代方案，比如使用 MongoDB 的 `$lookup` 聚合操作或者手动优化数据模型以减少对 `populate` 的依赖。

Populate will automatically replace the specified path in the document, with document(s) from other collection(s).

Your example

    Story.findOne({ title: Nintendo })
    

will return a Story of this kind:

    {
      _creator : A0jfdSMmEJj9, // example value
        title    : Nintendo,
        fans     : [r432i900fds09809n, fdsjifdsjfueu88] // example values
      }
    }
    

That kind of request would be enough when we don't care about the author or the fans, only their IDs.

But in the case where we need that `_creator`'s name, we would need to make another request to find it in the database.

In Mongoose we have function populate() that we can chain to our previous request to directly get that information in our answer without doing an additional request.

    Story.findOne({ title: Nintendo }).populate('_creator')
    

will return

    {
      _creator : {
           _id : A0jfdSMmEJj*9,
           name: Sai,
           age: 100,
           stories : [fdsfdsfdsew38u, 89hr3232, ...]
        },
        title    : Nintendo,
        fans     : [r432i900fds09809n, fdsjifdsjfueu88]
      }
    }
    

If that's too much information, and his age and name are enough but we don't want the stories that he wrote, populate can take another argument containing the field that we need.

    Story.findOne({ title: Nintendo }).populate('_creator', 'name age')
    

will return

    {
      _creator : {
           name: Sai,
           age: 100,
        },
        title    : Nintendo,
        fans     : [r432i900fds09809n, fdsjifdsjfueu88]
      }
    }

`populate()` function in mongoose is used for populating the data inside the reference. In your example `StorySchema` is having `_creator` field which will reference to the `_id` field which is basically the `ObjectId` of the mongodb document.

> populate() function can accept a string or an object as an input.

Where string is the field name which is required to be populated. In your case that is `_creator`. After mongoose found one doc from mongodb and the result of that is like below

    _creator: {
      name: "SomeName",
      age: SomeNumber,
      stories: [Set Of ObjectIDs of documents in stories collection in mongodb]
    },
    title: "SomeTitle",
    fans: [Set of ObjectIDs of documents in persons collection in mongodb]
    

> populate can also accept the object as an input.

You can find the documents of mongoose's `populate()` function here : [http://mongoosejs.com/docs/2.7.x/docs/populate.html](http://mongoosejs.com/docs/2.7.x/docs/populate.html) or [https://mongoosejs.com/docs/populate.html](https://mongoosejs.com/docs/populate.html)

.populate() is being used in order to bring only needed information.

**EXAMPLE without .populate()**

    User.findOne({ name: Bob })
    

Will return

    {
      Bob : {
        _id : dasd348ew,
        email: bob@example.com,
        age: 25,
        job: teacher,
        nationality: American,
      }
    }
    

**EXAMPLE with .populate()**

    User.findOne({ name: Bob }).populate("Bob", "job email")
    

Will return

    {
      Bob : {
        job: teacher,
        email: bob@example.com,
      }
    }

[This answer](https://stackoverflow.com/a/53002303/8784518) to this question is not complete if you need to populate across multiple levels. We can use it to get a list of a user's friends. But to retrieve friends of a user's friends we can do this:

    const userSchema = new Schema({
      name: String,
      friends: [{ type: ObjectId, ref: 'User' }]
    });
    
    User.
      findOne({ name: 'Val' }).
      populate({
        path: 'friends',
        // Get friends of friends - populate the 'friends' array for every friend
        populate: { path: 'friends' }
      });

Mongoose 中的 populate 的作用是什么？

在Node.js中使用Mongoose操作MongoDB时，我们经常需要处理大量的数据。为了有效地处理这些数据，我们可能会使用游标(cursor)。游标允许我们遍历查询结果，而不必一次性将所有结果加载到内存中。在Mongoose中，我们可以通过使用`find()`方法后接`cursor()`方法来获取一个游标。接下来，我们可以使用`foreach`循环来迭代游标中的每个文档。

下面是一个使用`foreach`游标的例子：

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

// 首先，定义模型的schema
const userSchema = new Schema({
  name: String,
  age: Number
});

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

// 连接到MongoDB数据库
mongoose.connect('mongodb://localhost:27017/myapp');

// 一旦连接到数据库，我们就可以通过游标来处理数据
mongoose.connection.on('open', function() {
  const cursor = User.find().cursor();

  // 使用foreach迭代游标
  cursor.eachAsync(function(user) {
    // 这里你可以对每个用户(user)进行操作
    console.log(user.name);
  })
  .then(() => {
    console.log('所有用户处理完毕');
    mongoose.disconnect(); // 处理完成后记得断开数据库连接
  })
  .catch(err => {
    console.error('处理过程中发生错误:', err);
  });
});
```

以上代码展示了如何在Mongoose中使用游标来迭代数据库中的用户集合。通过调用`eachAsync`方法，我们可以为每一个迭代到的文档执行一个异步操作，该操作在本例中是一个简单的控制台日志输出。处理完成后，我们通过`then`链来关闭数据库连接，这样做可以确保所有数据都已经被处理完毕。如果在迭代过程中遇到任何错误，`catch`块将捕获这些错误并输出。

这种方法特别适用于需要处理大量数据且不想一次性加载到内存中的情况，可以有效防止内存溢出问题。

The answer depends on the driver you're using. All MongoDB drivers I know have `cursor.forEach()` implemented one way or another.

Here are some examples:

[node-mongodb-native](https://github.com/mongodb/node-mongodb-native)
=====================================================================

    collection.find(query).forEach(function(doc) {
      // handle
    }, function(err) {
      // done or error
    });
    

[mongojs](https://github.com/mafintosh/mongojs)
===============================================

    db.collection.find(query).forEach(function(err, doc) {
      // handle
    });
    

[monk](https://github.com/LearnBoost/monk)
==========================================

    collection.find(query, { stream: true })
      .each(function(doc){
        // handle doc
      })
      .error(function(err){
        // handle error
      })
      .success(function(){
        // final callback
      });
    

[mongoose](http://mongoosejs.com/)
==================================

    collection.find(query).stream()
      .on('data', function(doc){
        // handle doc
      })
      .on('error', function(err){
        // handle error
      })
      .on('end', function(){
        // final callback
      });
    

Updating documents inside of `.forEach` callback
================================================

The only problem with updating documents inside of `.forEach` callback is that you have no idea when all documents are updated.

To solve this problem you should use some asynchronous control flow solution. Here are some options:

*   [async](https://github.com/caolan/async)
*   promises ([when.js](https://github.com/cujojs/when), [bluebird](https://github.com/petkaantonov/bluebird))

Here is an example of using `async`, using its [`queue` feature](https://github.com/caolan/async#queueworker-concurrency):

    var q = async.queue(function (doc, callback) {
      // code for your update
      collection.update({
        _id: doc._id
      }, {
        $set: {hi: 'there'}
      }, {
        w: 1
      }, callback);
    }, Infinity);
    
    var cursor = collection.find(query);
    cursor.each(function(err, doc) {
      if (err) throw err;
      if (doc) q.push(doc); // dispatching doc to async.queue
    });
    
    q.drain = function() {
      if (cursor.isClosed()) {
        console.log('all items have been processed');
        db.close();
      }
    }

Using the `mongodb` driver, and modern NodeJS with async/await, a good solution is to use [`next()`](http://mongodb.github.io/node-mongodb-native/3.1/api/Cursor.html#next):

    const collection = db.collection('things')
    const cursor = collection.find({
      bla: 42 // find all things where bla is 42
    });
    let document;
    while ((document = await cursor.next())) {
      await collection.findOneAndUpdate({
        _id: document._id
      }, {
        $set: {
          blu: 43
        }
      });
    }
    

This results in only one document at a time being required in memory, as opposed to e.g. the accepted answer, where many documents get sucked into memory, before processing of the documents starts. In cases of "huge collections" (as per the question) this may be important.

If documents are large, this can be improved further by using a [projection](http://mongodb.github.io/node-mongodb-native/3.1/api/Collection.html#find), so that only those fields of documents that are required are fetched from the database.

Nodejs 如何基于 mongoose 中使用 foreach 游标？

在Mongoose中，`findOne` 方法用于在MongoDB数据库中查询并返回匹配特定查询条件的单个文档。这个方法接受一个查询对象作为参数，该对象指定了我们希望查找的文档的条件。返回的是一个满足条件的文档，如果没有找到，则返回 `null`。

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

假设我们有一个名为 `User` 的模型，它代表一个用户集合。我们想查询一个用户名为 "johndoe" 的用户：

```javascript
const mongoose = require('mongoose');
const User = mongoose.model('User', new mongoose.Schema({
  username: String,
  email: String,
  password: String
}));

async function findUserByUsername(username) {
  try {
    // 使用 findOne 方法查找一个用户名为 'johndoe' 的用户
    const user = await User.findOne({ username: username });

    if (user) {
      // 用户被找到
      console.log(`User found: ${user}`);
      return user;
    } else {
      // 用户未找到
      console.log('User not found.');
      return null;
    }
  } catch (error) {
    // 错误处理
    console.error('An error occurred:', error);
  }
}

// 调用函数并传入用户名 'johndoe'
findUserByUsername('johndoe');
```

在上面的代码示例中，我们首先引入了 `mongoose` 并定义了一个 `User` 模型，该模型具有用户名（username）、电子邮件（email）和密码（password）属性。

我们定义了一个异步函数 `findUserByUsername`，它接受一个用户名作为参数，然后使用 `findOne` 方法根据提供的用户名查询用户。查询参数是一个对象，即 `{ username: username }`，在这里我们希望 `username` 字段与传入的 `username` 参数相匹配。

该函数使用 `await` 关键字等待 `findOne` 的执行结果，这意味着在返回结果之前，JavaScript 的事件循环可以继续处理其他事情。如果查询成功，并且找到了对应的用户，它将打印出找到的用户并将其返回。如果没有找到用户，则输出 "User not found."。如果查询过程中发生错误，则会捕获该错误，并在控制台中打印出来。

Found the problem, need to use `function(err,obj)` instead:

    Auth.findOne({nick: 'noname'}, function(err,obj) { console.log(obj); });

Mongoose basically wraps mongodb's api to give you a pseudo relational db api so queries are not going to be exactly like mongodb queries. Mongoose **findOne** query returns a query object, **not a document**. You can either use a callback as the solution suggests or as of v4+ **findOne** returns a thenable so you can use .then or await/async to retrieve the document.

    // thenables
    Auth.findOne({nick: 'noname'}).then(err, result) {console.log(result)};
    Auth.findOne({nick: 'noname'}).then(function (doc) {console.log(doc)});
    
    // To use a full fledge promise you will need to use .exec()
    var auth = Auth.findOne({nick: 'noname'}).exec();
    auth.then(function (doc) {console.log(doc)});
    
    // async/await
    async function async auth() {
      const doc = await Auth.findOne({nick: 'noname'}).exec();
      return doc;
    }
    auth();
    
    

See the [docs](https://mongoosejs.com/docs/promises.html) if you would like to use a third party promise library.

In my case same error is there , I am using Asyanc / Await functions , for this needs to add AWAIT for findOne

    Ex:const foundUser = User.findOne ({ "email" : req.body.email });
    

above , foundUser always contains Object value in both cases either user found or not because it's returning values before finishing findOne .

    const foundUser = await User.findOne ({ "email" : req.body.email });
    

above , foundUser returns null if user is not there in collection with provided condition . If user found returns user document.

You might want to consider using `console.log` with the built-in "arguments" object:

    console.log(arguments); // would have shown you [0] null, [1] yourResult
    

This will always output all of your arguments, no matter how many arguments you have.

Mongoose 如何使用 findOne？

在Mongoose中，限制查询特定字段可以通过以下两种主要方法实现：投影（Projection）和`select`方法。

### 投影（Projection）

投影是在查询时指定哪些字段应该返回给用户。在MongoDB和Mongoose中，可以在查询时通过第二个参数定义投影。例如，假设你有一个用户模型`User`，你只想获取他们的`name`和`email`字段，你可以这样写：

```javascript
User.find({}, 'name email', function(err, users) {
  if (err) {
    // 处理错误
  } else {
    // 处理查询结果
  }
});
```

上面的代码中，`'name email'`就是一个投影，表示只返回`name`和`email`字段。如果你想排除某些字段，比如不想要`password`字段，可以在字段前加上`-`来表示排除：

```javascript
User.find({}, '-password', function(err, users) {
  if (err) {
    // 处理错误
  } else {
    // 处理查询结果
  }
});
```

### `select`方法

另一种方法是使用Mongoose查询的`select`方法。该方法允许你更链式地构建查询，并且可以更灵活地指定或排除字段。使用`select`方法时，你也可以使用空格分隔字段名称来指定需要返回的字段，或者使用`-`来排除字段。例如：

```javascript
User.find().select('name email').exec(function(err, users) {
  if (err) {
    // 处理错误
  } else {
    // 处理查询结果
  }
});
```

或者排除某个字段：

```javascript
User.find().select('-password').exec(function(err, users) {
    if (err) {
        // 处理错误
    } else {
        // 处理查询结果
    }
});
```

在这个例子中，我们使用了链式写法，首先是`User.find()`来初始化查询，接着是`.select('name email')`来指定返回的字段，最后是`.exec()`来执行查询并处理结果。

值得注意的是，使用排除法时，默认情况下`_id`字段会被包含，除非你显式地排除它。如果你不想返回`_id`字段，你可以这样写：

```javascript
User.find().select('name email -_id').exec(function(err, users) {
    if (err) {
        // 处理错误
    } else {
        // 处理查询结果
    }
});
```

这些方法也可以与其他查询条件和选项结合使用，以进行更复杂的查询。通过这样的方式，你可以精确控制在Mongoose查询中返回哪些数据，以及如何返回这些数据。

the [docs](http://mongoosejs.com/docs/api.html#model_Model.find) say you can achieve this like so:

**Mongoose v4.0**

    // Retrieving only certain fields
    
    Model.find({}, 'first last', function (err, docs) {
    
    });
    

**old outdated API**

    // Retrieving only certain fields
    
    Model.find({}, ['first', 'last'], function (err, docs) {
      // docs is an array of partially-`init`d documents
      // defaults are still applied and will be "populated"
    });
    

so you can do this without `select()`.

this is another way: [queries in mongoose](http://mongoosejs.com/docs/queries.html)

    Transaction.find({username : user.username})
    .select('uniqueId confirmation_link item_name timeout username')
    .exec(function(err, txs) {
            console.log(txs);
    });

Now there is a shorter way of doing this (not using `.select` and not using an array), just passing the fields separate by spaces as the second argument

    User.find({}, 'first last', function (err, usr) {
        //Got the result, saved a few bytes of code
    });
    

[The Docs](http://mongoosejs.com/docs/api.html#model_Model.find)

Select method is used to select which fields are to be returned in the query result, excluding select means we want all the other fields to be returned, here is simple usage as per the docs.

    // include a and b, exclude other fields  
    query.select('a b');
    
    // exclude c and d, include other fields  
    query.select('-c -d');
    

More information here, [https://mongoosejs.com/docs/api.html#query\_Query-select](https://mongoosejs.com/docs/api.html#query_Query-select)

To retrieve certain fields without retrieving the '\_id' you can specify to exclude it

    Model.find({}, {'Username':1, '_id':0}, function ( err, docs ){}.....

Mongoose 如何限制查询特定的字段？

在Mongoose中，如果你想同时更新多个文档，可以使用`updateMany`方法。这个方法允许你根据指定的查询条件来更新所有匹配的文档。下面是一个例子：

假设有一个名为`User`的模型，该模型代表一个用户集合，我们想要将所有用户的`isActive`字段从`false`更新为`true`。

```javascript
const mongoose = require('mongoose');
const User = mongoose.model('User', new mongoose.Schema({
  isActive: Boolean
}));

async function updateMultipleUsers() {
  try {
    const filter = { isActive: false }; // 定义匹配条件
    const update = { isActive: true };  // 定义更新的内容

    // 使用updateMany将所有匹配filter的文档的isActive字段更新为true
    const result = await User.updateMany(filter, update);

    // result会包含更新操作的结果，例如匹配的文档数和实际更新的文档数
    console.log(result);
  } catch (error) {
    console.error('Error updating users:', error);
  }
}

// 调用函数以执行更新
updateMultipleUsers();
```

在这个例子中，我们首先定义了一个用于匹配要更新的文档的`filter`对象，这里它只有一个属性`isActive`，我们要匹配所有`isActive`为`false`的文档。然后，我们定义了一个`update`对象来指定要对匹配的文档进行的更新操作，即将`isActive`设置为`true`。

接着，我们调用`User.updateMany`方法，并传入这两个对象。这个方法返回一个Promise，所以我们可以使用`await`关键字等待它的完成。完成后，它会返回一个包含操作结果的对象，其中包括了匹配的文档数量和实际更新的文档数量。

如果需要应用更复杂的更新操作，比如使用MongoDB的更新操作符（例如`$set`，`$inc`等），你可以在`update`对象中包含这些操作符。此外，还可以传入一个选项对象来自定义操作的行为，例如是否要返回更新后的文档等。

Currently I believe that `update()` in Mongoose has some problems, see: [https://groups.google.com/forum/#%21topic/mongoose-orm/G8i9S7E8Erg](https://groups.google.com/forum/#%21topic/mongoose-orm/G8i9S7E8Erg) and [https://groups.google.com/d/topic/mongoose-orm/K5pSHT4hJ\_A/discussion](https://groups.google.com/d/topic/mongoose-orm/K5pSHT4hJ_A/discussion).

However, check the docs for update: [http://mongoosejs.com/docs/api.html](http://mongoosejs.com/docs/api.html) (its under Model). The definition is:

**Earlier Solution(Depreciated after mongoose 5+ version)**

    Model.update = function (query, doc, options, callback) { ... }
    

You need to pass the options inside an object, so your code would be:

    Model.update = function ({}, {cid: ''}, {multi: true}, function(err) { ... });
    

**New Solution**

    Model.updateMany = function (query, doc, callback) { ... }
    
    Model.updateMany = function ({}, {cid: ''}, function(err) { ... });
    

I believe that Mongoose wraps your cid in a $set, so this is not the same as running that same update in the mongo shell. If you ran that in the shell then all documents would be replaced by one with a single `cid: ''`.

Those answers are deprecated. This is the actual solution:

    Device.updateMany({}, { cid: '' });

You have to use the multi: true option

    Device.update({},{cid: ''},{multi: true});

as mentioned in the [mongoose documents](https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/) this is how we do this:

`db.collection.updateMany(condition, update, options, callback function)`

so this is an example based on the docs:

        // creating arguments
        let conditions = {};
        let update = {
            $set : {
          title : req.body.title,
          description : req.body.description,
          markdown : req.body.markdown
          }
        };
        let options = { multi: true, upsert: true };
    
        // update_many :)
        YourCollection.updateMany(
    
          conditions, update, options,(err, doc) => {
            console.log(req.body);
            if(!err) {
              res.redirect('/articles');
            }
            else {
              if(err.name == "ValidationError"){
                handleValidationError(err , req.body);
                res.redirect('/new-post');
              }else {
                res.redirect('/');
              }
            }
          });
    

this worked fine for me, I hope it helps :)

await Device.updateMany({_id: {$in: cid}},{ $set: {columnNameHere: "columnValueHere"}},{multi:true,upsert: true,new: true});

Mongoose 如何同时更新多个文档？

在使用Mongoose进行数据检索时，您可以通过在查询中添加特定的选项来排除某些字段。这是通过在查询的`select`方法中设置字段为`0`或者使用`-`符号排除字段来实现的。以下是几个示例：

### 示例 1：使用对象字面量排除字段

```javascript
// 假设我们有一个User模型
User.find({ /* 查询条件 */ })
    .select({ password: 0, __v: 0 }) // 排除password和__v字段
    .exec((err, users) => {
      // 处理结果
    });
```

在这个例子中，我们在`select`方法中使用一个对象，其中将不想包含的字段设置为`0`。

### 示例 2：使用字符串排除字段

```javascript
User.find({ /* 查询条件 */ })
    .select('-password -__v') // 使用字符串，以-开头表示排除字段
    .exec((err, users) => {
      // 处理结果
    });
```

在这个例子中，我们在`select`方法中使用了一个字符串，字段名前加上`-`符号表示排除该字段。

### 示例 3：在查询构造器中直接指定

```javascript
User.find({ /* 查询条件 */ }, '-password -__v', (err, users) => {
    // 处理结果
});
```

在这个例子中，我们直接在`find`方法的第二个参数中指定排除的字段。

### 示例 4：使用`projection`对象在`findOne`中排除字段

```javascript
User.findOne({ /* 查询条件 */ }, { password: 0, __v: 0 }, (err, user) => {
    // 处理结果
});
```

在这个例子中，我们在`findOne`方法中使用了`projection`对象来排除某些字段。

### 示例 5：链式查询中排除字段

```javascript
User.find({ /* 查询条件 */ })
    .select('-password')
    .lean()
    .exec((err, users) => {
      // 处理结果
    });
```

在这个例子中，我们展示了如何在链式查询中使用`select`方法排除字段。

这种排除字段的方法是出于性能和安全性的考虑，比如你不希望将密码、用户IDs以及其他敏感信息发送给客户端。

Another way to handle this on the schema level is to override toJSON for the model.

    UserSchema.methods.toJSON = function() {
      var obj = this.toObject()
      delete obj.passwordHash
      return obj
    }
    

I came across this question looking for a way to exclude password hash from the json i served to the client, and `select: false` broke my verifyPassword function because it didn't retrieve the value from the database at all.

The documented way is

    UserSchema.set('toJSON', {
        transform: function(doc, ret, options) {
            delete ret.password;
            return ret;
        }
    });
    

**UPDATE - You might want to use a white list:**

    UserSchema.set('toJSON', {
        transform: function(doc, ret, options) {
            var retJson = {
                email: ret.email,
                registered: ret.registered,
                modified: ret.modified
            };
            return retJson;
        }
    });

Come across your question when I was trying to find a similar answer with pymongo. It turns out that in mongo shell, with the find() function call, you can pass a second parameter which specifies how the result document looks like. When you pass a dictionary with attribute's value being 0, you are excluding this field in all the document that come out of this query.

In your case, for example, the query will be like:

    db.user.find({an_attr: a_value}, {_creator: 0});
    

It will exclude \_creator parameter for you.

In pymongo, the find() function is pretty much the same. Not sure how it translate to mongoose though. I think it's a better solution compare to manually delete the fields afterwards.

Hope it helps.

I would use the lodash utilities [_.pick()_](http://lodash.com/docs#pick) _or [](http://lodash.com/docs#omit)_ [.omit()](http://lodash.com/docs#omit)

    var _ = require('lodash');
    
    app.post('/example.json', function (req, res) {
        var user = new User({name: 'John', age: 45, _creator: 'some ObjectId'});
        user.save(function (err) {
            if (err) throw err;
            // Only get name and age properties
            var userFiltered = _.pick(user.toObject(), ['name', 'age']);
            res.json(200, {user: user});
        });
    });
    

The other example would be:

    var _ = require('lodash');
    
    app.post('/example.json', function (req, res) {
        var user = new User({name: 'John', age: 45, _creator: 'some ObjectId'});
        user.save(function (err) {
            if (err) throw err;
            // Remove _creator property
            var userFiltered = _.omit(user.toObject(), ['_creator']);
            res.json(200, {user: user});
        });
    });

You can call [`toObject()`](http://mongoosejs.com/docs/api.html#document_Document-toObject) on the document to convert it to a plain JS object that you can freely modify:

    user = user.toObject();
    delete user._creator;
    res.json(200, {user: user});

Mongoose 如何在搜素时排除某些字段？

Mongoose 是一个面向 MongoDB 的对象数据模型（ODM）库，它为在 Node.js 中使用 MongoDB 提供了便捷的 API。在Mongoose中，`save`、`insert`和`create`函数都用于将数据保存到MongoDB数据库中，但它们各自的使用场景和工作方式略有不同。

### `save` 方法
`save` 方法是Mongoose模型实例上的一个方法。它用于将一个模型实例（document）保存到数据库中。如果该模型实例是新创建的，则执行插入（insert）操作；如果该模型实例已经存在于数据库中（通常是通过查询得到的），则执行更新（update）操作。

**示例：**
```javascript
const kitty = new Cat({ name: 'Zildjian' });
kitty.save((err, savedKitty) => {
  if (err) return console.error(err);
  console.log(savedKitty.name + ' saved to database.');
});
```

### `insert` 方法
`insert` 是MongoDB原生驱动的方法，Mongoose 通过 `Model.collection.insert` 或者 `Model.insertMany` 方法暴露了这一功能。这个方法通常用于批量插入多个文档到数据库中，不会进行模型的验证（validation），不会应用默认值，并且不会执行Mongoose的中间件（middleware）。

**示例：**
```javascript
Cat.insertMany([{ name: 'Kitty' }, { name: 'Catnip' }], (err, docs) => {
  if (err) return console.error(err);
  console.log('Multiple cats inserted to database.');
});
```

### `create` 方法
`create` 方法是一个模型（model）上的静态方法，它不仅可以创建单个文档，也可以创建多个文档，并将它们保存到数据库中。与 `insertMany` 不同，`create` 方法会进行模型验证，应用模型的默认值，并且可以触发Mongoose的中间件。

**示例：**
```javascript
Cat.create({ name: 'Fluffy' }, (err, createdCat) => {
  if (err) return console.error(err);
  console.log(createdCat.name + ' created and saved to database.');
});
```

或者创建多个文档：
```javascript
Cat.create([{ name: 'Fluffy' }, { name: 'Paws' }], (err, createdCats) => {
  if (err) return console.error(err);
  createdCats.forEach(cat => console.log(cat.name + ' created and saved to database.'));
});
```

### 总结
- **save**: 用于保存单个文档，可以是新文档（insert）也可以是更新已有文档（update），执行模型验证、应用默认值，并触发中间件。
- **insert**: 通过MongoDB驱动提供的能力，用于批量插入文档，不进行Mongoose层面的验证、不应用默认值，不触发中间件。
- **create**: 创建一个或多个文档并保存，执行模型验证、应用默认值，并触发中间件，适合需要验证和应用模型默认值的场景。

在实际应用中，选择哪一个方法取决于具体的场景和需求。例如，如果需要批量插入数据且不关心验证和默认值，可能会选择 `insertMany`。如果在插入数据的同时需要验证和应用默认值，则可能会选择 `create`。而 `save` 通常用于处理单个文档，并且在已有实例的基础上进行更新操作。

The `.save()` is an instance method of the model, while the `.create()` is called directly from the `Model` as a method call, being static in nature, and takes the object as a first parameter.

    var mongoose = require('mongoose');
    
    var notificationSchema = mongoose.Schema({
        "datetime" : {
            type: Date,
            default: Date.now
        },
        "ownerId":{
            type:String
        },
        "customerId" : {
            type:String
        },
        "title" : {
            type:String
        },
        "message" : {
            type:String
        }
    });
    
    var Notification = mongoose.model('Notification', notificationsSchema);
    
    
    function saveNotification1(data) {
        var notification = new Notification(data);
        notification.save(function (err) {
            if (err) return handleError(err);
            // saved!
        })
    }
    
    function saveNotification2(data) {
        Notification.create(data, function (err, small) {
        if (err) return handleError(err);
        // saved!
        })
    }
    

Export whatever functions you would want outside.

More at the [Mongoose Docs](http://mongoosejs.com/docs/models.html), or consider reading the reference of the [`Model`](http://mongoosejs.com/docs/api.html#Model) prototype in Mongoose.

**TLDR: Use Create (save is expert-mode)**

The main difference between using the create and save methods in Mongoose is that create is a convenience method that automatically calls new Model() and save() for you, while save is a method that is called on a Mongoose document instance.

When you call the create method on a Mongoose model, it creates a new instance of the model, sets the properties, and then saves the document to the database. This method is useful when you want to create a new document and insert it into the database in one step. This makes the creation an atomic transaction. Therefore, the save method leaves the potential to create inefficiencies/inconsistencies in your code.

On the other hand, the save method is called on an instance of a Mongoose document, after you have made changes to it. This method will validate the document and save the changes to the database.

Another difference is that create method can insert multiple documents at once, by passing an array of documents as parameter, while save is intended to be used on a single document.

So, if you want to create a new instance of a model and save it to the database in one step, you can use the create method. If you have an existing instance of a model that you want to save to the database, you should use the save method.

Also, if you have any validation or pre-save hook in your content schema, this will be triggered when using the create method.

You can either use `save()` or `create()`.

`save()` can only be used on a new document of the model while `create()` can be used on the model. Below, I have given a simple example.

Tour Model
----------

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

Tour Controller
---------------

    const Tour = require('../models/tourModel');
    
    exports.createTour = async (req, res) => {
      // method 1
      const newTour = await Tour.create(req.body);
    
      // method 2
      const newTour = new Tour(req.body);
      await newTour.save();
    }
    

Make sure to use either Method 1 or Method 2.

I'm quoting Mongoose's [Constructing Documents](https://mongoosejs.com/docs/models.html#constructing-documents) documentation:

    const Tank = mongoose.model('Tank', yourSchema);
    
    const small = new Tank({ size: 'small' });
    small.save(function (err) {
      if (err) return handleError(err);
      // saved!
    });
    
    // or
    
    Tank.create({ size: 'small' }, function (err, small) {
      if (err) return handleError(err);
      // saved!
    });
    
    // or, for inserting large batches of documents
    Tank.insertMany([{ size: 'small' }], function(err) {
    
    });

Mongoose 中 save， insert 以及 create 三者之间的区别？

在Mongoose中，`__v`属性是一个版本键，默认情况下会添加到MongoDB文档中，用于表示文档的版本。如果要在查询时从结果中排除这个属性，有多种方法可以做到。

### 1. 查询时明确排除`__v`属性

在执行查询时，可以通过在查询的`projection`参数中设置`__v: 0`来排除这个字段。

```javascript
Model.find({}, { __v: 0 }).then(result => {
    console.log(result);
});
```

### 2. 使用Schema的选项来全局隐藏`__v`

在定义Mongoose Schema时，可以设置`versionKey`为`false`，这样在该模型的所有实例中都会隐藏`__v`字段。

```javascript
const schema = new mongoose.Schema({ name: String }, { versionKey: false });
const Model = mongoose.model('Model', schema);

const doc = new Model({ name: 'Hide __v example' });
console.log(doc); // `__v` will not be part of the document
```

### 3. 使用虚拟属性来过滤`__v`

虚拟属性是Mongoose中一个非常灵活的特性，你可以定义一个虚拟属性来获取除去`__v`字段后的文档对象。

```javascript
schema.virtual('documentWithoutVersionKey').get(function() {
    const obj = this.toObject();
    delete obj.__v;
    return obj;
});
```

之后，你可以使用这个虚拟属性来获取没有`__v`属性的文档对象。

### 4. 使用`toJSON`和`toObject`转换选项

在Schema定义中，也可以通过设置`toJSON`和`toObject`的transform选项来排除`__v`。

```javascript
schema.set('toJSON', {
    transform: function(doc, ret, options) {
        delete ret.__v;
        return ret;
    }
});

schema.set('toObject', {
    transform: function(doc, ret, options) {
        delete ret.__v;
        return ret;
    }
});
```

这样在每次调用`toJSON()`或`toObject()`方法时，`__v`字段都会被自动排除。

### 实例

例如，假设我有一个用户模型，并且我不希望在任何API响应中返回`__v`字段，我可以在定义该用户Schema时设置`versionKey: false`：

```javascript
const userSchema = new mongoose.Schema({
    username: String,
    email: String
}, { versionKey: false });

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

这样，无论何时创建用户模型的实例，都不会包含`__v`字段。

总结来说，隐藏`__v`属性可以根据项目要求，在查询时动态排除，或者在模型定义时通过Schema选项进行全局设置。

You can disable the "\_\_v" attribute in your Schema definitions by setting the `versionKey` option to `false`. For example:

    var widgetSchema = new Schema({ ... attributes ... }, { versionKey: false });
    

I don't think you can globally disable them, but can only do it per Schema. You can read more about Schema's [options here](http://mongoosejs.com/docs/guide.html#versionKey). You might also find the [Schema set method](http://mongoosejs.com/docs/api.html#schema_Schema-set) helpful.

To disable '\_\_v' property, which is not recommended, use the [`versionKey` schema option](http://mongoosejs.com/docs/guide.html#versionKey):

    var Schema = new Schema({...}, { versionKey: false });
    

To hide it from all queries, which sometimes can be [not what you want too](https://stackoverflow.com/a/15025570/2153350), use the [`select` schema type option](http://mongoosejs.com/docs/api.html#schematype_SchemaType-select):

    var Schema = new Schema({ __v: { type: Number, select: false}})

Two ways:

1.  `{versionKey: false}`
    
2.  when you query, like `model.findById(id).select('-__v')`
    

`'-'` means exclude the field

define a `toObject.transform` function, and make sure you always call `toObject` when getting documents from mongoose.

    var SomeSchema = new Schema({
        <some schema spec>
      } , {
        toObject: {
          transform: function (doc, ret, game) {
            delete ret.__v;
          }
        }
    });

Try this it will remove \_v from every query response.

    // transform for sending as json
    function omitPrivate(doc, obj) {
        delete obj.__v;
        return obj;
    }
    
    // schema options
    var options = {
        toJSON: {
            transform: omitPrivate
        }
    };
    // schema
    var Schema = new Schema({...}, options);

Mongoose 如何隐藏 __v 属性？

在Mongoose中，要获取最新的文档记录或者最旧的文档记录，可以通过排序（Sorting）和限制返回结果数量来实现。

比如说，您有一个名为 `Article` 的模型，该模型表示一个博客文章的集合。每个文档都有一个 `createdAt` 字段，该字段会在创建新文档时自动设置为当前日期和时间。

获取最新的文档记录，您可以使用 `.findOne()` 方法结合 `.sort()` 方法，按照 `createdAt` 字段的降序排列，并限制结果为1：

```javascript
// 获取最新的文章记录
Article.findOne().sort('-createdAt').exec((err, latestDocument) => {
  if (err) {
    console.error(err);
  } else {
    console.log('最新的文档记录是:', latestDocument);
  }
});
```

这里，`'-createdAt'` 代表了按照 `createdAt` 字段的降序排列。如果您想获取最旧的文档记录，只需要将排序改为升序：

```javascript
// 获取最旧的文章记录
Article.findOne().sort('createdAt').exec((err, oldestDocument) => {
  if (err) {
    console.error(err);
  } else {
    console.log('最旧的文档记录是:', oldestDocument);
  }
});
```

这样，您就可以根据需要获取最新或最旧的文档记录。如果您的文档中没有 `createdAt` 或其他可以用于排序的时间戳字段，那么您需要添加一个时间戳字段或者使用其他字段进行排序。

Mongoose 3.x is complaining about the `[]` parameter in your [`findOne`](https://mongoosejs.com/docs/api/model.html#model_Model.findOne) calls as the array format is no longer supported for the parameter that selects the fields to include.

Try this instead to find the newest:

    Tweet.findOne({}, {}, { sort: { 'created_at' : -1 } }, function(err, post) {
      console.log( post );
    });
    

Change the `-1` to a `1` to find the oldest.

But because you're not using any field selection, it's somewhat cleaner to chain a couple calls together:

    Tweet.findOne().sort({created_at: -1}).exec(function(err, post) { ... });
    

Or even pass a string to [`sort`](http://mongoosejs.com/docs/api.html#query_Query-sort):

    Tweet.findOne().sort('-created_at').exec(function(err, post) { ... });

### Fast and Simple - One Line Solution

Get **`10 latest documents`**

    MySchema.find().sort({ _id: -1 }).limit(10)
    

Get **`10 oldest documents`**

    MySchema.find().sort({ _id: 1 }).limit(10)
    

In case you want sorting based on some other property i.e. `createdAt` and get the oldest or latest. It is similar to the above query.

    MySchema.find().sort({ createdAt: -1 }).limit(10)  // 10 latest docs
    MySchema.find().sort({ createdAt: 1 }).limit(10) // 10 oldest docs

for version ~3.8 mongoose

to find the last entry

    model.findOne().sort({ field: 'asc', _id: -1 }).limit(1)
    

or using

    model.findOne().sort({ field: -_id }).limit(1)

collectionName.findOne().sort({$natural: -1}).limit(1).exec(function(err, res){
        if(err){
            console.log(err);
        }
        else{
            console.log(res);
        }
    }
    

This will give you the last document recorded on the database. Just follow the same concept.

await Model.find().sort({$natural:-1}).limit(1); //for the latest record
    await Model.find().sort({$natural:1}).limit(1); //for the oldest record
    

This one works for me. using mongodb natural order [https://docs.mongodb.com/manual/reference/operator/meta/natural/](https://docs.mongodb.com/manual/reference/operator/meta/natural/)

Mongoose 如何获取最新文档纪录或者最旧文档记录？

在 Mongoose 中，如果您想要将模型中的某个字段设置为 `ObjectId` 数据类型，通常是为了创建一个引用其他MongoDB文档的字段。您可以使用 `Schema.Types.ObjectId` 来指定字段类型。这通常与 `ref` 选项结合使用，以指明该 `ObjectId` 引用的模型。

以下是一个如何在Mongoose模型中定义 `ObjectId` 字段的例子：

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

// 定义一个新的Schema
const userSchema = new Schema({
  // ... 其他字段
  // 这里定义了一个名为`profile`的字段，它引用了`Profile`模型
  profile: {
    type: Schema.Types.ObjectId,
    ref: 'Profile'
  }
});

// 创建一个名为`User`的模型
const User = mongoose.model('User', userSchema);
```

在上述例子中，`profile` 字段被设置为 `ObjectId` 类型，并且通过 `ref` 属性与 `Profile` 模型相关联。这意味着 `profile` 字段应该包含一个存储在 `Profile` 集合中的文档的ID。

当您在使用Mongoose查询包含 `ObjectId` 引用的文档时，可以使用 `.populate()` 方法来自动替换这些字段的 `ObjectId` 为关联文档的数据。例如：

```javascript
User.findById(userId)
  .populate('profile') // 这会获取 `profile` 字段引用的 `Profile` 文档
  .exec((err, user) => {
    if (err) {
      // 处理错误
    } else {
      // 这里的 `user.profile` 将是一个完整的 `Profile` 文档而不只是一个ID
      console.log(user.profile);
    }
  });
```

这个 `.populate()` 调用告诉Mongoose，在查询完成时填充 `profile` 字段，而不仅仅是返回 `ObjectId`。这样，您就可以访问关联的 `Profile` 文档的所有信息。

Unlike traditional RBDMs, mongoDB doesn't allow you to define any random field as the primary key, the \_id field MUST exist for all standard documents.

For this reason, it doesn't make sense to create a separate uuid field.

In mongoose, the ObjectId type is used not to create a new uuid, rather it is mostly used to reference other documents.

Here is an example:

    var mongoose = require('mongoose');
    
    var Schema = mongoose.Schema,
        ObjectId = Schema.ObjectId;
    var Schema_Product = new Schema({
        categoryId  : ObjectId, // a product references a category _id with type ObjectId
        title       : String,
        price       : Number
    });
    

As you can see, it wouldn't make much sense to populate categoryId with a ObjectId.

However, if you do want a nicely named uuid field, mongoose provides virtual properties that allow you to proxy (reference) a field.

Check it out:

    var mongoose = require('mongoose');
    
    var Schema = mongoose.Schema,
        ObjectId = Schema.ObjectId;
    var Schema_Category = new Schema({
        title       : String,
        sortIndex   : String
    });
    
    Schema_Category.virtual('categoryId').get(function() {
        return this._id;
    });
    

So now, whenever you call category.categoryId, mongoose just returns the \_id instead.

You can also create a "set" method so that you can set virtual properties, check out [this link](http://mongoosejs.com/docs/virtuals.html) for more info

I was looking for a different answer for the question title, so maybe other people will be too.

To set type as an ObjectId (so you may reference `author` as the author of `book`, for example), you may do like:

    const Book = mongoose.model('Book', {
      author: {
        type: mongoose.Schema.Types.ObjectId, // here you set the author ID
                                              // from the Author colection, 
                                              // so you can reference it
        required: true
      },
      title: {
        type: String,
        required: true
      }
    });

My solution on using ObjectId

    // usermodel.js
    
    const mongoose = require('mongoose')
    const Schema = mongoose.Schema
    const ObjectId = Schema.Types.ObjectId
    
    
    let UserSchema = new Schema({
       username: {
         type: String
       },
       events: [{
         type: ObjectId,
         ref: 'Event' // Reference to some EventSchema
       }]
    })
    
    UserSchema.set('autoIndex', true)
    
    module.exports = mongoose.model('User', UserSchema)
    

Using mongoose's [populate](http://mongoosejs.com/docs/populate.html) method

    // controller.js
    
    const mongoose = require('mongoose')
    const User = require('./usermodel.js')
    
    let query = User.findOne({ name: "Person" })
    
    query.exec((err, user) => {
      if (err) {
         console.log(err)
      }
    
      user.events = events
      // user.events is now an array of events
    })

The solution provided by @dex worked for me. But I want to add something else that also worked for me: Use

    let UserSchema = new Schema({
       username: {
         type: String
       },
       events: [{
         type: ObjectId,
         ref: 'Event' // Reference to some EventSchema
       }]
    })
    

if what you want to create is an Array reference. But if what you want is an Object reference, which is what I think you might be looking for anyway, remove the brackets from the _value_ prop, like this:

    let UserSchema = new Schema({
       username: {
         type: String
       },
       events: {
         type: ObjectId,
         ref: 'Event' // Reference to some EventSchema
       }
    })
    

Look at the 2 snippets well. In the second case, the value prop of key events does not have brackets over the object def.

You can directly define the ObjectId

var Schema = new mongoose.Schema({ categoryId : mongoose.Schema.Types.ObjectId, title : String, sortIndex : String })

Note: You need to import the mongoose module

如何在mongoose中将objectid设置为数据类型

在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 })));

Mongoose 如何保存复杂的 json 数据？

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

Mongoose 中 id 和 _id 的区别是什么？

在 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
    });

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

Mongoose 如何在同一个查询指令中同时使用 populate 和 aggregate ？

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

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.

Mongoose 为什么既有 model 又有 schema ?

在 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");
    });

Mongoose 如何在保存文档后获取文档的 objectID ？

在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

Mongoose 如何将 objectID 转化化为字符串？

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

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;
         }
    });

Mongoose相关问题