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


Mongoose

在 Node.js 中，如果您使用的是 Mongoose.js 来与 MongoDB 数据库交互，将字符串转换为ObjectId对象是一项常见的任务，特别是当您需要用字符串形式的 ID 对数据库中的文档进行引用或查询时。Mongoose.js 中内置了一个 `ObjectId` 类型，它是 MongoDB 官方的 `bson` 库的一部分。

假设您得到了一个字符串形式的 ID，如 `'5f8d0d55b54764421b7156d9'`，并希望将其转换为 `ObjectId` 对象，您可以按照以下步骤操作：

1. 首先，确保您已经安装了 mongoose：
   
   ```bash
   npm install mongoose
   ```

2. 在您的 Node.js 代码中，引入 `mongoose` 包，并使用 `mongoose.Types.ObjectId` 来创建一个新的 `ObjectId` 实例：

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

   // 假设我们有一个字符串形式的 ID
   const idString = '5f8d0d55b54764421b7156d9';

   // 使用 mongoose 的 Types.ObjectId 方法来转换
   const objectId = mongoose.Types.ObjectId(idString);

   console.log(objectId); // 这将输出一个有效的 ObjectId 对象
   ```

3. 确保传入的字符串是有效的 ObjectId 字符串。它应该是一个24个字符长的字符串，包含 12 字节的数据（通常是16进制表示的）。

如果您传入的字符串不是有效的 ObjectId，Mongoose 会抛出一个错误提示。在实际应用中，您可能需要对这种情况进行处理，例如：

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

const idString = 'invalid-object-id';

try {
  const objectId = mongoose.Types.ObjectId(idString);
  console.log(objectId);
} catch (error) {
  console.error('Error converting string to ObjectId:', error.message);
}
```

确保您捕获并妥善处理任何可能因无效的字符串输入而抛出的错误，以避免在您的应用程序中引入 bug。

你可以这样做：

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

你也可以用这个

    const { ObjectId } = require('mongodb');
    const _id = ObjectId("4eb6e7e7e9b7f4194e000001");
    

这是最简单的方法

你可以这样做：

    var mongoose = require('mongoose');
    var _id = mongoose.mongo.BSONPure.ObjectID.fromHexString("4eb6e7e7e9b7f4194e000001");
    

编辑：新标准有 fromHexString 而不是 fromString

从评论来看，您正在寻找：

    mongoose.mongo.BSONPure.ObjectID.isValid
    

或者

    mongoose.Types.ObjectId.isValid

var mongoose = require('mongoose');
    var _id = mongoose.mongo.ObjectId("4eb6e7e7e9b7f4194e000001");

How to transform the string to objectid function in mongoose

当您在Mongoose中定义模式时，`created_at`和`updated_at`字段通常用于跟踪记录的创建和最后更新时间。要在Mongoose中添加这两个字段，您可以使用内置的`timestamps`选项，它会自动为您的模式添加这两个字段。以下是一个如何在Mongoose模式中实现它的示例：

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

const Schema = mongoose.Schema;

// 定义模式
const exampleSchema = new Schema({
  // 模式的其他字段
  name: {
    type: String,
    required: true
  },
  description: {
    type: String
  }
  // 您不需要显式添加created_at和updated_at字段
}, {
  timestamps: true // 这将会自动添加created_at和updated_at字段
});

// 创建模型
const ExampleModel = mongoose.model('Example', exampleSchema);

module.exports = ExampleModel;
```

在这个例子中，`timestamps`选项被设置为`true`，这告诉Mongoose自动为每个模式实例添加`createdAt`和`updatedAt`字段。当您创建一个新的文档时，Mongoose会自动设置`createdAt`和`updatedAt`字段的值为当前时间戳。当您更新文档时，只有`updatedAt`字段会被更新为最新的时间戳。

默认情况下，这些字段被命名为`createdAt`和`updatedAt`。如果您想要自定义这些字段的名称，可以通过传递一个包含`createdAt`和`updatedAt`属性的对象来实现：

```javascript
const exampleSchema = new Schema({
  // 模式的其他字段
  name: {
    type: String,
    required: true
  },
  description: {
    type: String
  }
}, {
  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' } // 自定义字段名称
});
```

通过使用`timestamps`选项，您可以确保每次创建或更新文档时，这些字段都会自动得到处理，这样可以在不增加额外代码的情况下轻松跟踪文档的历史。

**更新：**（5年后）

> **注意：**如果您决定使用[Kappa 架构](http://milinda.pathirage.org/kappa-architecture.com/)（_事件溯源 + CQRS_），那么您根本不需要更新日期。由于您的数据是不可变的、仅附加的事件日志，因此您只需要事件创建日期。类似于_Lambda 架构_，如下所述。那么您的应用程序状态是事件日志（派生数据）的投影。如果您收到有关现有实体的后续事件，则您将使用该事件的创建日期作为实体的更新日期。这是微服务系统中常用（且常被误解）的做法。

**更新：**（4年后）

如果您使用`ObjectId`作为您的`_id`字段（通常是这种情况），那么您需要做的就是：

    let document = {
      updatedAt: new Date(),
    }
    

检查下面我的原始答案，了解如何从`_id`字段获取创建的时间戳。如果您需要使用外部系统的 ID，请查看 Roman Rhrn Nesterov 的答案。

**更新：**（2.5年后）

现在，您可以将[#timestamps](http://mongoosejs.com/docs/guide.html#timestamps)选项与 mongoose 版本 >= 4.0 一起使用。

    let ItemSchema = new Schema({
      name: { type: String, required: true, trim: true }
    },
    {
      timestamps: true
    });
    

如果设置时间戳、猫鼬分配`createdAt`和`updatedAt`字段到您的模式，分配的类型是`Date`。

您还可以指定时间戳字段的名称：

    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }
    

> **注意：**如果您正在开发包含关键数据的大型应用程序，您应该重新考虑更新文档。我建议您使用不可变的、仅附加的数据（[lambda 架构](https://en.wikipedia.org/wiki/Lambda_architecture)）。这意味着您只允许插入。**不允许更新和删除！**如果您想“删除”一条记录，您可以轻松插入带有某些`timestamp`/的文档的新版本`version` ，然后将`deleted`字段设置为`true`。类似地，如果您想更新文档 - 您创建一个新文档，更新相应的字段并复制其余字段。然后，为了查询该文档，您将获得具有最新时间戳或最高版本的文档，即未“删除”（该`deleted`字段未定义或 false\`）。
> 
> 数据不变性确保您的数据是可调试的——您可以跟踪每个文档的历史记录。如果出现问题，您还可以回滚到文档的先前版本。如果您采用这样的架构`ObjectId.getTimestamp()`就足够了，并且它不依赖于 Mongoose。

* * *

**原答案：**

如果您使用 ObjectId 作为身份字段，则不需要`created_at`字段。ObjectIds 有一个名为 的方法`getTimestamp()`。

ObjectId("507c7f79bcf86cd7994f6c0e").getTimestamp()

这将返回以下输出：

ISODate("2012-10-15T21:26:17Z")

更多信息请点击这里[如何从 Mongo ObjectID 中提取创建日期](https://stackoverflow.com/questions/7327296/how-do-i-extract-the-created-date-out-of-a-mongo-objecti)

为了添加`updated_at`字段，您需要使用以下命令：

    var ArticleSchema = new Schema({
      updated_at: { type: Date }
      // rest of the fields go here
    });
    
    ArticleSchema.pre('save', function(next) {
      this.updated_at = Date.now();
      next();
    });

从 Mongoose 4.0 开始，您现在可以在 Schema 上设置时间戳选项，让 Mongoose 为您处理此问题：

    var thingSchema = new Schema({..}, { timestamps: true });
    

您可以更改所使用字段的名称，如下所示：

    var thingSchema = new Schema({..}, { timestamps: { createdAt: 'created_at' } });
    

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

这就是我最终所做的：

    var ItemSchema = new Schema({
        name    : { type: String, required: true, trim: true }
      , created_at    : { type: Date }
      , updated_at    : { type: Date }
    });
    
    
    ItemSchema.pre('save', function(next){
      now = new Date();
      this.updated_at = now;
      if ( !this.created_at ) {
        this.created_at = now;
      }
      next();
    });

使用您的架构的内置`timestamps`选项。

    var ItemSchema = new Schema({
        name: { type: String, required: true, trim: true }
    },
    {
        timestamps: true
    });
    

这会自动将`createdAt`和`updatedAt`字段添加到您的架构中。

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

像这样添加`timestamps`到你的然后会自动为你生成`Schema``createdAt``updatedAt`

    var UserSchema = new Schema({
        email: String,
        views: { type: Number, default: 0 },
        status: Boolean
    }, { timestamps: {} });
    

[![在此输入图像描述](https://i.stack.imgur.com/pLmsj.png)](https://i.stack.imgur.com/pLmsj.png)  
您也可以`createdAt -> created_at`通过以下方式更改

    timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }

How to add created at and updated at fields to mongoose schemas?

Mongoose 中的 `__v` 字段是一个隐藏字段，它代表了文档的版本号。这个字段由 Mongoose 在内部使用，主要目的是为了支持文档的版本控制，使用乐观锁定机制来避免并发修改时的冲突。

每当在 Mongoose 中创建或保存文档时，如果该文档包含数组字段，并且执行了会修改数组的操作（例如，添加或删除元素），Mongoose 会自动更新这个 `__v` 字段的值。这样，当多个用户或进程同时尝试修改同一文档时，Mongoose 可以通过检查 `__v` 字段的值来确定文档是否已经被其他方修改过，从而决定是否允许当前的修改操作继续执行。

这个版本号是自动维护的，开发者通常不需要手动修改它。当然，如果不需要这个字段，也可以在定义 Mongoose Schema 时通过选项 `{ versionKey: false }` 禁用它。

例如，如果我们定义一个简单的用户模型，并希望禁用 `__v` 字段，我们可以这样做：

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

const userSchema = new Schema({
  name: String,
  email: String,
  password: String
}, { versionKey: false }); // 禁用 __v 字段

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

但在大多数情况下，开发者都保留这个字段，以便可以利用其提供的并发修改控制的功能。

从[这里](http://mongoosejs.com/docs/guide.html#versionKey)：

> 这`versionKey`是 Mongoose 首次创建每个文档时设置的属性。该键值包含文档的内部修订。该文档属性的名称是可配置的。默认为`__v`.
> 
> 如果这与您的应用程序冲突，您可以这样配置：

    new Schema({..}, { versionKey: '_somethingElse' })

好吧，我看不到托尼的解决方案……所以我必须自己处理……

* * *

如果您不需要 version\_key，您可以：

    var UserSchema = new mongoose.Schema({
        nickname: String,
        reg_time: {type: Date, default: Date.now}
    }, {
        versionKey: false // You should be aware of the outcome after set to false
    });
    

将 versionKey 设置为 false 意味着文档不再受版本控制。

如果文档包含子文档数组，则会出现问题。可以删除其中一个子文档，从而减小数组的大小。稍后，另一个操作可以访问数组中原始位置的子文档。

由于数组现在较小，因此可能会意外访问数组中的错误子文档。

versionKey 通过将文档与 versionKey 相关联来解决这个问题，mongoose 在内部使用 versionKey 来确保它访问正确的集合版本。

更多信息请访问：[http://aaronheckmann.blogspot.com/2012/06/mongoose-v3-part-1-versioning.html](http://aaronheckmann.blogspot.com/2012/06/mongoose-v3-part-1-versioning.html)

要在 NestJS 中删除，需要向`Schema()`装饰器添加选项

    @Schema({ versionKey: false })

如果不需要，可以禁用版本密钥。

看这个例子：

    var User = new mongoose.Schema({
       FullName:{
           type :String,
          
       },
       BirthDay:{
           type :String,
           
       },
       Address:{
           type :String,
       },
       Gender:{
           type:String,
       },
       PhoneNumber:{
           type:Number,
           ref:'Account'
       },
       AccountID:{
            type: Schema.Types.ObjectId,
            ref: 'Account'
       },
       UserName:{
           type:String,
           ref:'Account'
       }
    },{collection:'User',
       versionKey: false //here
    });

我们“文档”中的“\_\_v”字段服务于“ **optimisticConcurrency”**问题。

这个术语在 mongoose 中基本上意味着：让您通过“findOne, findById”抓取文档，但**尚未**使用 mongoose 的 save() 方法。如果在此时间间隔内，任何其他代码获取相同的文档并在第一个文档实例之前使用 .save() 方法，该怎么办？在这个用例中，如果我们想（特定于猫鼬）抛出版本错误之类的事情，我们`optimisticConcurrency: true`在模式中使用选项。

**然后 mongoose 将使用 '\_\_v1' 来比较这两个文档。**

没有`optimisticConcurrency: true`选择。'\_\_v' 没有效果。并且 mongoose 不会将其增加 1。

注意：在“findOneAndUpdate”类似操作中，不会更新“\_\_v”。（仅 save() 更新）

What is the " __v " field in Mongoose

MongoDB 是一个非关系型数据库管理系统，也被称为NoSQL数据库，它使用文档存储和JSON样式的查询语言，非常适合处理大量数据和高并发的场景。MongoDB 存储数据的基本单元是文档（Document），这些文档被组织在集合（Collection）中，一个集合相当于关系数据库中的表（Table）。MongoDB 的主要特点包括横向可扩展性、灵活的文档模型以及支持复杂的查询操作。

Mongoose 则是一个运行在Node.js环境下的对象数据模型（ODM）库，用于连接Node.js应用与MongoDB数据库。它的主要功能是提供了一套简洁的Schema定义接口、中间件处理逻辑和数据验证功能，使得开发者可以用类似于传统ORM框架的方式来处理MongoDB文档数据。Mongoose通过定义Schema来管理数据结构，并提供了一系列的方法和属性，使得在Node.js中操作MongoDB变得更加直观和方便。

举例来说，假设我们需要在一个博客系统中存储用户信息，使用MongoDB，我们直接操作数据库来插入、查询、更新或删除文档。而使用Mongoose，我们会先定义一个用户的Schema，指定字段及其类型，然后基于这个Schema创建一个模型（Model），通过这个模型来进行数据的CRUD操作。这样的好处是，我们的操作是类型安全的，并且可以很方便地进行数据验证和中间件处理。简而言之，Mongoose作为一个抽象层存在，为MongoDB的操作提供了更多的结构和简便性。

例如，使用Mongoose时，定义用户模型代码可能如下：

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

const userSchema = new Schema({
  username: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  }
});

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

module.exports = User;
```

然后，我们可以用这个模型来创建新用户，如下：

```javascript
const User = require('./path/to/user.model');

const newUser = new User({
  username: 'johndoe',
  password: '123456',
  email: 'johndoe@example.com'
});

newUser.save()
  .then(() => console.log('User created!'))
  .catch(error => console.error('Error creating user:', error));
```

在这个例子中，Mongoose会处理数据的验证，保证存入数据库的数据符合我们预先定义的Schema。而如果直接使用MongoDB，我们需要手动编写这些验证逻辑。

我假设您已经知道 MongoDB 是一个 NoSQL 数据库系统，它以 BSON 文档的形式存储数据。然而，您的问题是关于 Node.js 的包。

就 Node.js 而言，[mongodb](https://www.npmjs.com/package/mongodb)是与 mongodb 实例交互的**本机驱动程序，** [mongoose](https://www.npmjs.com/package/mongoose)是 MongoDB 的**对象建模工具。**

`mongoose`构建在`mongodb`驱动程序之上，为程序员提供一种对其数据进行建模的方法。

**编辑：** 我不想评论哪个更好，因为这会使这个答案变得固执己见。不过，我将列出使用这两种方法的一些优点和缺点。

使用`mongoose`，用户可以定义特定集合中文档的架构。它为MongoDB中数据的创建和管理提供了很多便利。不利的一面是，学习猫鼬可能需要一些时间，并且在处理非常复杂的模式方面有一些限制。

但是，如果您的集合模式不可预测，或者您希望在 Node.js 中获得类似 Mongo-shell 的体验，那么请继续使用该`mongodb`驱动程序。这是最简单的拾取方式。这样做的缺点是您必须编写大量代码来验证数据，并且出错的风险更高。

Mongo 是 NoSQL 数据库。

如果您不想对数据模型使用任何[ORM ，那么您还可以使用本机驱动程序 mongo.js：https:](https://en.wikipedia.org/wiki/Object-relational_mapping) [//github.com/mongodb/node-mongodb-native](https://github.com/mongodb/node-mongodb-native)。

Mongoose 是 Orm 之一，它为我们提供了通过易于理解的查询来访问 mongo 数据的功能。

Mongoose 充当数据库模型的抽象角色。

我发现两者的另一个区别是，它相当容易使用，`connect to multiple databases`但`mongodb native driver`您必须使用`mongoose`仍然存在一些缺点的解决方法。

因此，如果您想要多租户应用程序，请选择 mongodb 本机驱动程序。

从第一个答案来看，

“使用 Mongoose，用户可以为特定集合中的文档定义模式。它为 MongoDB 中的数据创建和管理提供了很多便利。”

您现在还可以使用 mongoDB 本机驱动程序定义架构

##新系列

    db.createCollection("recipes",
        validator: { $jsonSchema: {
             <<Validation Rules>>
            }
        }
    )
    

##对于现有集合

    db.runCommand({
        collMod: "recipes",
        validator: { $jsonSchema: {
             <<Validation Rules>>
            }
        }
    })
        
    

##完整示例

    db.createCollection("recipes", {
      validator: {
        $jsonSchema: {
          bsonType: "object",
          required: ["name", "servings", "ingredients"],
          additionalProperties: false,
          properties: {
            _id: {},
            name: {
              bsonType: "string",
              description: "'name' is required and is a string"
            },
            servings: {
              bsonType: ["int", "double"],
              minimum: 0,
              description:
                "'servings' is required and must be an integer with a minimum of zero."
            },
            cooking_method: {
              enum: [
                "broil",
                "grill",
                "roast",
                "bake",
                "saute",
                "pan-fry",
                "deep-fry",
                "poach",
                "simmer",
                "boil",
                "steam",
                "braise",
                "stew"
              ],
              description:
                "'cooking_method' is optional but, if used, must be one of the listed options."
            },
            ingredients: {
              bsonType: ["array"],
              minItems: 1,
              maxItems: 50,
              items: {
                bsonType: ["object"],
                required: ["quantity", "measure", "ingredient"],
                additionalProperties: false,
                description: "'ingredients' must contain the stated fields.",
                properties: {
                  quantity: {
                    bsonType: ["int", "double", "decimal"],
                    description:
                      "'quantity' is required and is of double or decimal type"
                  },
                  measure: {
                    enum: ["tsp", "Tbsp", "cup", "ounce", "pound", "each"],
                    description:
                      "'measure' is required and can only be one of the given enum values"
                  },
                  ingredient: {
                    bsonType: "string",
                    description: "'ingredient' is required and is a string"
                  },
                  format: {
                    bsonType: "string",
                    description:
                      "'format' is an optional field of type string, e.g. chopped or diced"
                  }
                }
              }
            }
          }
        }
      }
    });
    

插入集合示例

    db.recipes.insertOne({
      name: "Chocolate Sponge Cake Filling",
      servings: 4,
      ingredients: [
        {
          quantity: 7,
          measure: "ounce",
          ingredient: "bittersweet chocolate",
          format: "chopped"
        },
        { quantity: 2, measure: "cup", ingredient: "heavy cream" }
      ]
    });

Mongodb 和 Mongoose 是与 MongoDB 数据库交互的两个不同的驱动程序。

**Mongoose**：对象数据建模（ODM）库，为您的数据提供严格的建模环境。用于与 MongoDB 交互，通过提供管理数据的便利使生活变得更轻松。

**Mongodb**：Node.js 中用于与 MongoDB 交互的本机驱动程序。

Mongoose相关问题

How to transform the string to objectid function in mongoose

How to add created at and updated at fields to mongoose schemas?

What is the " __v " field in Mongoose

What is the difference between mongodb and mongoose