0Pricing
MongoDB Academy · 课时

Mongoose 模式、模型和虚拟属性

您将定义带有类型、验证和默认选项的 Mongoose 模式，创建模型并添加虚拟属性。

Mongoose 模式、模型和虚拟属性 是 CoddyKit 上的免费 MongoDB Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 MongoDB Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 MongoDB Academy 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What Is Mongoose?

Mongoose is an Object Document Mapper (ODM) for MongoDB and Node.js. It sits on top of the official MongoDB driver and adds a layer of abstraction: schemas for validating document structure, models for database interaction, middleware hooks for pre/post operation logic, and virtuals for computed fields. Mongoose is the most popular MongoDB library in the Node.js ecosystem and is especially productive for server applications with well-defined data models.

// Install Mongoose
// npm install mongoose

const mongoose = require('mongoose');

// Connect to MongoDB
await mongoose.connect(process.env.MONGODB_URI);
console.log('Mongoose connected to MongoDB');

Defining a Schema

A Mongoose Schema defines the structure, types, and constraints of documents in a collection. Each key in the schema corresponds to a document field. You can specify type, required, default, min, max, enum, and many other validation options per field. Schemas are the single source of truth for your document structure in a Mongoose application.

const { Schema } = mongoose;

const userSchema = new Schema({
  name: {
    type: String,
    required: [true, 'Name is required'],
    trim: true,
    maxlength: 100
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true  // automatically converts to lowercase before saving
  },
  age: {
    type: Number,
    min: [0, 'Age cannot be negative'],
    max: 150
  },
  role: {
    type: String,
    enum: ['admin', 'user', 'guest'],
    default: 'user'
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

Schema Types: Supported Types

Mongoose supports a rich set of schema types. The most common are String, Number, Date, Boolean, Buffer, mongoose.Schema.Types.ObjectId (for references), Array (denoted as [Type]), and Mixed (any value, no type checking). Mongoose also supports nested schemas (sub-documents) by nesting a Schema definition inside another Schema's field definition.

const { Schema } = mongoose;
const { ObjectId } = Schema.Types;

const orderSchema = new Schema({
  customerId: { type: ObjectId, ref: 'User', required: true }, // reference to User model
  items: [
    {
      productId: { type: ObjectId, ref: 'Product' },
      quantity: { type: Number, min: 1 },
      price: Number
    }
  ],
  total: Number,
  status: { type: String, default: 'pending' },
  metadata: Schema.Types.Mixed,  // accepts any shape
  tags: [String],                // array of strings
  shippedAt: Date
});

Timestamps Option

Passing { timestamps: true } as the second argument to the Schema constructor makes Mongoose automatically manage createdAt and updatedAt fields on every document. createdAt is set once on insertion, and updatedAt is updated on every save. You do not need to set these fields manually—Mongoose handles them transparently. This is a best practice for all production schemas.

const productSchema = new Schema(
  {
    name: { type: String, required: true },
    price: { type: Number, required: true },
    category: String,
    stock: { type: Number, default: 0 }
  },
  { timestamps: true }  // adds createdAt and updatedAt automatically
);

// Documents will have:
// { name: 'Laptop', price: 999, createdAt: Date, updatedAt: Date }

Creating a Model

A Model is a constructor compiled from a Schema. It provides the interface for querying and writing documents to the collection. Call mongoose.model('ModelName', schema) to create a model—the first argument is the singular name of the collection (Mongoose automatically pluralizes it: 'User' → 'users' collection). Models should be created once and exported as modules.

// Define schema
const userSchema = new mongoose.Schema({
  name: String,
  email: { type: String, unique: true },
  role: { type: String, default: 'user' }
}, { timestamps: true });

// Compile the model
const User = mongoose.model('User', userSchema);
// This creates/uses the 'users' collection

module.exports = User;

// Usage in another file:
// const User = require('./models/user');
// const user = await User.findOne({ email: 'alice@example.com' });

Creating Documents With new Model()

Create a new document instance using the model constructor: new User({ name: '...', ... }). This creates an in-memory document object with validation but does NOT save to the database. Call .save() on the instance to persist it, or use the static User.create() shorthand that combines both steps. Mongoose validates the document against the schema before saving and throws a ValidationError if constraints are violated.

// Method 1: new + save (two-step)
const user = new User({
  name: 'Alice',
  email: 'alice@example.com',
  role: 'admin'
});
await user.save(); // validates then saves to 'users' collection

// Method 2: User.create() shorthand
const user2 = await User.create({
  name: 'Bob',
  email: 'bob@example.com'
});
console.log('Created user ID:', user2._id);

// Method 3: insertMany for bulk
await User.insertMany([
  { name: 'Carol', email: 'carol@example.com' },
  { name: 'Dave', email: 'dave@example.com' }
]);

Virtual Properties

Virtuals are computed properties that are not stored in the database but are computed from other fields on the document. They behave like regular document fields in your application code but are never written to MongoDB. Common use cases: combining firstName and lastName into a fullName virtual, computing age from a birthDate field, or creating a public-facing url from an _id.

const personSchema = new mongoose.Schema({
  firstName: String,
  lastName: String,
  birthDate: Date
});

// Virtual: combines firstName and lastName
personSchema.virtual('fullName').get(function () {
  return this.firstName + ' ' + this.lastName;
  // Use regular function (not arrow function) to access 'this'
});

// Virtual with a setter for convenience
personSchema.virtual('fullName').get(function () {
  return this.firstName + ' ' + this.lastName;
}).set(function (v) {
  this.firstName = v.split(' ')[0];
  this.lastName = v.split(' ')[1];
});

const Person = mongoose.model('Person', personSchema);
const p = new Person({ firstName: 'Alice', lastName: 'Smith' });
console.log(p.fullName); // 'Alice Smith'

Including Virtuals in JSON Output

By default, virtuals are not included when converting a document to JSON (e.g., when sending it in an API response). To include them, either set { toJSON: { virtuals: true } } in the schema options or explicitly call doc.toJSON({ virtuals: true }). In Express apps, res.json(doc) calls toJSON() automatically, so setting toJSON: { virtuals: true } in the schema is the cleanest way to always include them.

const userSchema = new mongoose.Schema(
  {
    firstName: String,
    lastName: String
  },
  {
    toJSON: { virtuals: true },    // include virtuals in res.json()
    toObject: { virtuals: true }   // include virtuals in .toObject()
  }
);

userSchema.virtual('fullName').get(function () {
  return this.firstName + ' ' + this.lastName;
});

const user = new User({ firstName: 'Alice', lastName: 'Smith' });
console.log(JSON.stringify(user)); // includes 'fullName': 'Alice Smith'

Custom Validation in Schemas

Mongoose schemas support custom validator functions per field. The validator function receives the field value and must return true for valid or false (or throw an error) for invalid. You can also provide a custom error message. Custom validators run before .save() and can be asynchronous (useful for database-level uniqueness checks beyond the unique index).

const productSchema = new mongoose.Schema({
  name: String,
  price: {
    type: Number,
    required: true,
    validate: {
      validator: function (v) {
        return v > 0; // price must be positive
      },
      message: props => 'Price must be positive, got ' + props.value
    }
  },
  sku: {
    type: String,
    validate: {
      validator: function (v) {
        return /^[A-Z]{2}-\d{4}$/.test(v); // format: AB-1234
      },
      message: 'SKU must match format AB-1234'
    }
  }
});

Schema Methods and Statics

Schemas support instance methods (available on each document) and static methods (called on the Model class). Instance methods access this for the specific document, making them ideal for document-specific operations like comparing passwords or formatting output. Statics are useful for common queries or factory functions that don't operate on a specific instance.

const userSchema = new mongoose.Schema({ email: String, passwordHash: String });

// Instance method: available on each user document
userSchema.methods.checkPassword = function (candidatePassword) {
  return bcrypt.compare(candidatePassword, this.passwordHash);
};

// Static method: called on the User model
userSchema.statics.findByEmail = function (email) {
  return this.findOne({ email: email.toLowerCase() });
};

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

// Usage:
const user = await User.findByEmail('alice@example.com');  // static
const valid = await user.checkPassword('secret');          // instance method

Subdocuments vs Nested Schema Objects

Mongoose distinguishes between embedded subdocuments (defined as an array of schemas) and nested schema objects (a plain schema definition inside a field). Array subdocuments each get their own _id and can be manipulated as individual documents via doc.items.id(subId). Nested objects share the parent document's lifecycle. Use array subdocuments for ordered collections of records (order line items, comments). Use nested objects for one-to-one embedded structures (address, metadata).

// Nested object — no array, no _id per entry
const userSchema = new Schema({
  address: {
    street: String,
    city: String,
    zip: String
  }
});

// Array subdocuments — each item gets its own _id
const orderSchema = new Schema({
  items: [
    {
      productId: Schema.Types.ObjectId,
      quantity: Number,
      price: Number
      // _id auto-added to each item
    }
  ]
});

// Access subdocument by ID:
const item = order.items.id(someItemId);

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: Mongoose Schemas define document structure, types, and validation rules, Models are compiled from schemas and provide the query/write interface (Model.find(), new Model(), etc.), and virtuals are computed properties that exist in memory but are never stored in MongoDB — useful for derived fields like fullName or url. Next up we explore Mongoose's query API including chaining, .lean(), and comparison with the native driver.

常见问题解答

「Mongoose 模式、模型和虚拟属性」课时是免费的吗？

是的 — 「Mongoose 模式、模型和虚拟属性」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 MongoDB Academy 课程的其余内容，请升级到 CoddyKit PRO。 MongoDB Academy 课程共包含 4 节课。

「Mongoose 模式、模型和虚拟属性」这节课中我会学到什么？

您将定义带有类型、验证和默认选项的 Mongoose 模式，创建模型并添加虚拟属性。 你通过在浏览器中直接运行的动手代码来练习 MongoDB Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 MongoDB Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 MongoDB Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。

「Mongoose 模式、模型和虚拟属性」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 MongoDB Academy 课中编写并运行代码吗？

能。每节 MongoDB Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 使用官方 Node.js 驱动程序连接
  2. Mongoose 模式、模型和虚拟属性
  3. Mongoose 查询、链式调用和精简文档
  4. Mongoose 中间件：前置和后置钩子
← 返回 MongoDB Academy