虚拟属性（Virtuals）的使用

虚拟属性（Virtuals）的概念

虚拟属性是Mongoose中一种特殊的属性，它不会持久化到MongoDB数据库中，而是在运行时动态计算。虚拟属性通常用于组合或转换文档中的现有字段，或者基于文档的其他属性计算派生值。它们提供了一种灵活的方式来扩展文档的功能，而无需实际修改数据库结构。

虚拟属性有两种主要类型：

1. getter虚拟属性：用于计算并返回一个值
2. setter虚拟属性：用于将值分解并设置到其他字段

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

// 定义一个getter虚拟属性
userSchema.virtual('fullName').get(function() {
  return `${this.firstName} ${this.lastName}`;
});

// 定义一个setter虚拟属性
userSchema.virtual('fullName').set(function(name) {
  const split = name.split(' ');
  this.firstName = split[0];
  this.lastName = split[1];
});

虚拟属性的基本用法

定义虚拟属性非常简单，只需要在schema上调用virtual()方法即可。虚拟属性的getter函数中可以通过this访问当前文档实例。

const productSchema = new mongoose.Schema({
  name: String,
  price: Number,
  taxRate: Number
});

// 计算含税价格的虚拟属性
productSchema.virtual('priceWithTax').get(function() {
  return this.price * (1 + this.taxRate / 100);
});

const Product = mongoose.model('Product', productSchema);
const laptop = new Product({ name: 'Laptop', price: 1000, taxRate: 20 });

console.log(laptop.priceWithTax); // 输出: 1200

虚拟属性默认不会包含在查询结果中，除非显式指定。可以通过设置toJSON和toObject选项来包含虚拟属性：

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

虚拟属性的高级用法

1. 基于关系的虚拟属性

虚拟属性特别适合处理文档间的关系。例如，在博客系统中，我们可以为文章模型定义一个虚拟属性来获取评论数量：

const postSchema = new mongoose.Schema({
  title: String,
  content: String
});

const commentSchema = new mongoose.Schema({
  content: String,
  post: { type: mongoose.Schema.Types.ObjectId, ref: 'Post' }
});

postSchema.virtual('comments', {
  ref: 'Comment',
  localField: '_id',
  foreignField: 'post'
});

postSchema.virtual('commentCount', {
  ref: 'Comment',
  localField: '_id',
  foreignField: 'post',
  count: true
});

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

// 使用populate获取虚拟属性
Post.findOne().populate('comments').populate('commentCount').exec((err, post) => {
  console.log(post.comments); // 评论数组
  console.log(post.commentCount); // 评论数量
});

2. 条件虚拟属性

虚拟属性可以根据文档的其他字段动态计算不同的值：

const orderSchema = new mongoose.Schema({
  items: [{
    product: String,
    quantity: Number,
    price: Number
  }],
  discount: Number
});

orderSchema.virtual('total').get(function() {
  const subtotal = this.items.reduce((sum, item) => sum + (item.price * item.quantity), 0);
  return subtotal - (subtotal * (this.discount || 0) / 100);
});

orderSchema.virtual('hasDiscount').get(function() {
  return this.discount > 0;
});

3. 虚拟属性的链式调用

可以为一个虚拟属性同时定义getter和setter：

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

personSchema.virtual('age')
  .get(function() {
    const diff = Date.now() - this.birthDate.getTime();
    return Math.floor(diff / (1000 * 60 * 60 * 24 * 365.25));
  })
  .set(function(age) {
    const now = new Date();
    this.birthDate = new Date(now.getFullYear() - age, now.getMonth(), now.getDate());
  });

const person = new Person({ firstName: 'John', lastName: 'Doe' });
person.age = 30; // 设置虚拟属性会自动计算birthDate
console.log(person.birthDate); // 显示30年前的日期

虚拟属性的性能考虑

虽然虚拟属性非常有用，但在使用时需要注意性能问题：

1. 计算开销：复杂的虚拟属性计算可能会影响性能，特别是在处理大量文档时
2. 查询限制：虚拟属性不能用于查询条件，因为它们不存在于数据库中
3. 索引：虚拟属性不能被索引，因为它们不是数据库字段

对于性能敏感的场景，可以考虑：

• 预先计算并存储常用值
• 使用Mongoose的中间件在保存文档时更新相关字段
• 对于复杂计算，考虑使用聚合管道

// 使用pre-save钩子预先计算并存储虚拟属性的值
personSchema.pre('save', function(next) {
  if (this.isModified('birthDate')) {
    const diff = Date.now() - this.birthDate.getTime();
    this.age = Math.floor(diff / (1000 * 60 * 60 * 24 * 365.25));
  }
  next();
});

虚拟属性与实例方法的选择

虚拟属性和实例方法都可以用于扩展文档功能，但它们有不同的适用场景：

示例对比：

// 虚拟属性实现
userSchema.virtual('isAdult').get(function() {
  return this.age >= 18;
});

// 实例方法实现
userSchema.methods.isAdult = function(minAge = 18) {
  return this.age >= minAge;
};

// 使用方式
console.log(user.isAdult); // 虚拟属性
console.log(user.isAdult(21)); // 实例方法，可以传入不同参数

虚拟属性的实际应用案例

1. 格式化输出

虚拟属性常用于格式化文档数据以供显示：

const invoiceSchema = new mongoose.Schema({
  number: Number,
  date: Date,
  amount: Number,
  currency: String
});

invoiceSchema.virtual('formattedAmount').get(function() {
  return new Intl.NumberFormat('en-US', {
    style: 'currency',
    currency: this.currency
  }).format(this.amount);
});

invoiceSchema.virtual('formattedDate').get(function() {
  return this.date.toLocaleDateString('en-US', {
    year: 'numeric',
    month: 'long',
    day: 'numeric'
  });
});

2. 权限控制

虚拟属性可以用于基于用户权限动态显示或隐藏数据：

const documentSchema = new mongoose.Schema({
  title: String,
  content: String,
  isPrivate: Boolean,
  owner: { type: mongoose.Schema.Types.ObjectId, ref: 'User' }
});

documentSchema.virtual('safeContent').get(function() {
  if (this.isPrivate && !this.userHasAccess) {
    return 'This content is private';
  }
  return this.content;
});

// 在控制器中设置userHasAccess标志
doc.userHasAccess = checkUserAccess(user, doc);

3. 数据验证

虚拟属性可以用于复杂的数据验证：

const reservationSchema = new mongoose.Schema({
  startDate: Date,
  endDate: Date,
  room: { type: mongoose.Schema.Types.ObjectId, ref: 'Room' }
});

reservationSchema.virtual('duration').get(function() {
  return (this.endDate - this.startDate) / (1000 * 60 * 60 * 24);
});

reservationSchema.virtual('isValid').get(function() {
  return this.duration > 0 && this.duration <= 14; // 不超过两周
});

// 在保存前检查
reservationSchema.pre('save', function(next) {
  if (!this.isValid) {
    throw new Error('Invalid reservation duration');
  }
  next();
});

虚拟属性的测试

测试虚拟属性与测试普通属性类似，但需要注意虚拟属性是动态计算的：

describe('User Model', () => {
  it('should compute fullName virtual property', () => {
    const user = new User({ firstName: 'John', lastName: 'Doe' });
    expect(user.fullName).to.equal('John Doe');
  });

  it('should split fullName virtual property', () => {
    const user = new User();
    user.fullName = 'Jane Smith';
    expect(user.firstName).to.equal('Jane');
    expect(user.lastName).to.equal('Smith');
  });

  it('should include virtuals in JSON output', () => {
    const user = new User({ firstName: 'John', lastName: 'Doe' });
    const json = user.toJSON();
    expect(json.fullName).to.equal('John Doe');
  });
});

虚拟属性的限制和替代方案

虚拟属性虽然强大，但有一些限制：

1. 不能用于查询：无法在find()或findOne()中使用虚拟属性作为条件
2. 不能聚合：无法在聚合管道中使用虚拟属性
3. 不能索引：无法为虚拟属性创建索引

对于这些限制，可以考虑以下替代方案：

1. 使用真正的字段：对于频繁访问的计算结果，可以存储为实际字段
2. 使用$expr：在MongoDB 3.6+中，可以使用$expr进行字段间的比较
3. 使用聚合管道：对于复杂计算，可以使用聚合框架

// 替代方案示例：存储计算字段
const productSchema = new mongoose.Schema({
  name: String,
  price: Number,
  taxRate: Number,
  priceWithTax: Number
});

productSchema.pre('save', function(next) {
  this.priceWithTax = this.price * (1 + this.taxRate / 100);
  next();
});