静态方法与实例方法

在Mongoose中，静态方法和实例方法是两种不同的方法类型，它们分别作用于模型和文档，用于处理不同的逻辑场景。静态方法通常用于模型级别的操作，而实例方法则与具体文档绑定，处理文档级别的逻辑。

静态方法的特点与使用场景

静态方法是直接定义在模型上的方法，通过模型本身调用，而不是通过模型实例。这类方法通常用于执行与整个集合相关的操作，例如复杂的查询、聚合或数据统计。

在Mongoose中定义静态方法的方式如下：

const userSchema = new mongoose.Schema({
  name: String,
  age: Number
});

// 定义静态方法
userSchema.statics.findByAge = function(age) {
  return this.find({ age });
};

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

// 使用静态方法
const users = await User.findByAge(25);

静态方法非常适合以下场景：

1. 封装复杂查询逻辑
2. 实现模型级别的工具函数
3. 执行跨文档操作
4. 实现数据聚合功能

例如，我们可以创建一个统计用户数量的静态方法：

userSchema.statics.countByAgeRange = function(min, max) {
  return this.countDocuments({ 
    age: { $gte: min, $lte: max } 
  });
};

// 使用
const count = await User.countByAgeRange(20, 30);

实例方法的特点与使用场景

实例方法是定义在文档上的方法，通过具体的文档实例调用。这类方法通常用于处理单个文档相关的业务逻辑，如数据验证、文档操作等。

定义实例方法的语法如下：

userSchema.methods.getInfo = function() {
  return `Name: ${this.name}, Age: ${this.age}`;
};

const user = new User({ name: 'Alice', age: 25 });
console.log(user.getInfo()); // 输出: Name: Alice, Age: 25

实例方法常见的应用场景包括：

1. 文档级别的数据操作
2. 文档验证
3. 文档关系处理
4. 自定义文档行为

例如，我们可以创建一个更新用户年龄并验证的实例方法：

userSchema.methods.updateAge = function(newAge) {
  if(newAge < 0) {
    throw new Error('Age cannot be negative');
  }
  this.age = newAge;
  return this.save();
};

// 使用
const user = await User.findOne({ name: 'Alice' });
await user.updateAge(26);

静态方法与实例方法的比较

从调用方式来看，静态方法通过模型调用，而实例方法通过文档对象调用：

// 静态方法调用
User.someStaticMethod();

// 实例方法调用
const user = new User();
user.someInstanceMethod();

从作用范围来看，静态方法通常处理集合级别的操作，实例方法处理单个文档的操作：

// 静态方法处理多个文档
userSchema.statics.adjustAllAges = async function(increment) {
  return this.updateMany({}, { $inc: { age: increment } });
};

// 实例方法处理当前文档
userSchema.methods.incrementAge = function() {
  this.age += 1;
  return this.save();
};

实际应用中的组合使用

在实际开发中，静态方法和实例方法经常需要配合使用。例如，先通过静态方法查询文档，再使用实例方法处理文档：

// 定义静态方法查询活跃用户
userSchema.statics.findActiveUsers = function() {
  return this.find({ isActive: true });
};

// 定义实例方法发送通知
userSchema.methods.sendNotification = function(message) {
  console.log(`Sending "${message}" to ${this.name}`);
};

// 组合使用
const activeUsers = await User.findActiveUsers();
activeUsers.forEach(user => user.sendNotification('New feature available!'));

方法链式调用的实现

通过合理的设计，可以实现方法的链式调用，提高代码的可读性：

userSchema.methods.setName = function(name) {
  this.name = name;
  return this; // 返回this实现链式调用
};

userSchema.methods.setAge = function(age) {
  this.age = age;
  return this;
};

// 链式调用
const user = new User();
user.setName('Bob').setAge(30).save();

异步方法的处理

无论是静态方法还是实例方法，都可以处理异步操作：

// 异步静态方法
userSchema.statics.findOrCreate = async function(conditions, defaults) {
  let user = await this.findOne(conditions);
  if(!user) {
    user = new this({ ...conditions, ...defaults });
    await user.save();
  }
  return user;
};

// 异步实例方法
userSchema.methods.checkAgeAsync = async function() {
  await someAsyncOperation();
  return this.age > 18;
};

与虚拟属性的结合使用

实例方法可以与虚拟属性结合，实现更灵活的数据处理：

userSchema.virtual('nameWithAge').get(function() {
  return `${this.name} (${this.age})`;
});

userSchema.methods.logInfo = function() {
  console.log(`User: ${this.nameWithAge}`);
};

在中间件中的应用

静态方法和实例方法都可以在Mongoose中间件中使用：

userSchema.pre('save', function(next) {
  // 实例方法在pre-save钩子中使用
  this.updateTimestamp();
  next();
});

userSchema.methods.updateTimestamp = function() {
  this.updatedAt = new Date();
};

性能考虑

静态方法通常比实例方法更高效，特别是在处理批量操作时：

// 高效的方式 - 静态方法批量更新
userSchema.statics.incrementAllAges = function() {
  return this.updateMany({}, { $inc: { age: 1 } });
};

// 低效的方式 - 使用实例方法循环处理
userSchema.statics.incrementAllAgesSlow = async function() {
  const users = await this.find();
  for(const user of users) {
    user.age += 1;
    await user.save();
  }
};

类型定义与TypeScript支持

在使用TypeScript时，可以明确定义静态方法和实例方法的类型：

interface IUserMethods {
  getInfo(): string;
  updateAge(newAge: number): Promise<void>;
}

interface UserModel extends mongoose.Model<IUser, {}, IUserMethods> {
  findByAge(age: number): Promise<IUser[]>;
  countByAgeRange(min: number, max: number): Promise<number>;
}

const userSchema = new mongoose.Schema<IUser, UserModel, IUserMethods>({
  name: String,
  age: Number
});

常见错误与调试

在使用这些方法时，需要注意一些常见问题：

1. 混淆this的指向：

// 错误示例 - 箭头函数会改变this指向
userSchema.statics.findByName = (name) => {
  return this.find({ name }); // this将不再指向Model
};

// 正确写法
userSchema.statics.findByName = function(name) {
  return this.find({ name });
};

2. 忘记返回Promise：

// 错误示例
userSchema.methods.saveAndLog = function() {
  this.save(); // 没有返回Promise
};

// 正确写法
userSchema.methods.saveAndLog = function() {
  return this.save();
};

高级应用场景

对于更复杂的应用，可以结合静态方法和实例方法实现领域驱动设计：

// 静态方法作为工厂方法
userSchema.statics.createFromDTO = function(dto) {
  const user = new this();
  user.name = dto.fullName;
  user.age = calculateAge(dto.birthDate);
  return user;
};

// 实例方法实现业务逻辑
userSchema.methods.applyDiscount = function() {
  if(this.age < 18 || this.age > 65) {
    this.discount = 0.2;
  }
  return this.save();
};

测试策略

针对静态方法和实例方法的不同特点，测试策略也有所不同：

// 测试静态方法
describe('User static methods', () => {
  it('should find users by age', async () => {
    await User.create({ name: 'Test', age: 30 });
    const users = await User.findByAge(30);
    expect(users).toHaveLength(1);
  });
});

// 测试实例方法
describe('User instance methods', () => {
  it('should update age correctly', async () => {
    const user = new User({ name: 'Test', age: 30 });
    await user.updateAge(31);
    expect(user.age).toBe(31);
  });
});

与Mongoose插件的集成

静态方法和实例方法可以封装为Mongoose插件实现复用：

function timestampPlugin(schema) {
  // 添加静态方法
  schema.statics.findRecent = function(days = 7) {
    const date = new Date();
    date.setDate(date.getDate() - days);
    return this.find({ createdAt: { $gte: date } });
  };

  // 添加实例方法
  schema.methods.isRecent = function() {
    const weekAgo = new Date();
    weekAgo.setDate(weekAgo.getDate() - 7);
    return this.createdAt >= weekAgo;
  };
}

// 使用插件
userSchema.plugin(timestampPlugin);