装饰器

类装饰器（Class Decorators）

作用于类本身，接收类的构造函数作为唯一参数，可返回一个新类替换原来类。

🌰 示例：给类添加创建时间属性

function addCreateTime(constructor: Function) {
  constructor.prototype.createTime = new Date();
}

// 为 User 类扩展接口，声明 createTime 属性
interface User {
  createTime: Date;
}

@addCreateTime
class User {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

const user = new User("Alice");
console.log(user.createTime); // 不再报错，类型为 Date

🌰 示例：返回新类的示例

// ------- 返回新类的示例
function replaceClass<T extends { new (...args: any[]): {} }>(constructor: T) {
  return class extends constructor {
    newProperty = "new value"; // 添加新属性
    hello() {
      return "override"; // 覆盖方法
    }
  };
}

interface MyClass {
  newProperty: string;
  hello(): string;
}

@replaceClass
class MyClass {
  property = "old value";
  hello() {
    return "original";
  }
}

const instance = new MyClass();
console.log(instance.property); // "old value"
console.log(instance.newProperty); // "new value"
console.log(instance.hello()); // "override"

方法装饰器（Method Decorators）

作用于类的方法，接收 3 个参数：

• target: 对于静态方法是类本身，对于实例方法是类的原型对象。

• propertyKey：方法名（字符串或 symbool）

• descrpotr：方法的属性描述符（PropertyDescriptor）

🌰 示例：可返回一个新的属性描述符替换原方法。

// 日志装饰器
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value; // 保存原方法

  // 重写方法
  descriptor.value = function (...args: any[]) {
    console.log(`调用方法 ${propertyKey}，参数：`, args);
    const result = originalMethod.apply(this, args); // 执行原方法
    console.log(`方法 ${propertyKey} 返回：`, result);
    return result;
  };
  return descriptor;
}

class Calculator {
  @log
  add(a: number, b: number): number {
    return a + b;
  }
}

const calc = new Calculator();
calc.add(2, 3); // 输出日志并返回 5

访问器装饰器（Accessor Decorators）

作用于类的 getter/setter 访问器，参数与方法装饰器相同，但不能同时装饰一个访问器的 get 和 set，需装饰在第一个访问器上。

//  显示 setter 赋值范围
function limitRange(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalSetter = descriptor.set;

  descriptor.set = function (value: number) {
    if (value < 0 || value > 100) {
      throw new Error("值必须在 0-100 之间");
    }
    originalSetter?.call(this, value);
  };
  return descriptor;
}

class Score {
  private _value: number = 0;

  @limitRange
  set value(v: number) {
    this._value = v;
  }

  get value() {
    return this._value;
  }
}

const score = new Score();
score.value = 90; // 正常赋值
score.value = 110; // 抛出错误

属性装饰器（Property Decorators）

作用于类的属性，接收 2 个参数：

• target: 对于静态方法是类本身，对于实例方法是类的原型对象。

• propertyKey：方法名（字符串或 symbool）

属性装饰器无法直接修改属性的定义（因无 descriptor 参数），通常需结合元数据（如 reflect-metadata）使用。

// 使用元数据记录属性类型

import "reflect-metadata"; // 需安装 reflect-metadata 库

const propTypeKey = Symbol("propType");

function propType(type: string) {
  return function (target: any, propertyKey: string) {
    Reflect.defineMetadata(propTypeKey, type, target, propertyKey);
  };
}

class User {
  @propType("string")
  name: string;

  @propType("number")
  age: number;
}

const user = new User();
console.log(Reflect.getMetadata(propTypeKey, user, "name")); // "string"
console.log(Reflect.getMetadata(propTypeKey, user, "age")); // "number"

参数装饰器（Parameter Decorators）

作用于方法的参数，接收 3 个参数：

• target：同方法装饰器。

• propertyKey：方法名。

• parameterIndex：参数在方法参数列表中的索引（从 0 开始）。

通常用于记录参数元数据（如依赖注入标记）。

// 标记参数为必填
import "reflect-metadata";

const requiredKey = Symbol("required");

function required(target: any, propertyKey: string, parameterIndex: number) {
  const requiredParams: number[] = Reflect.getMetadata(requiredKey, target, propertyKey) || [];
  requiredParams.push(parameterIndex);
  Reflect.defineMetadata(requiredKey, requiredParams, target, propertyKey);
}

// 方法装饰器：校验必填参数
function validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    const requiredParams = Reflect.getMetadata(requiredKey, target, propertyKey) || [];
    requiredParams.forEach((index: number) => {
      if (args[index] === undefined || args[index] === null) {
        throw new Error(`参数 ${index} 为必填`);
      }
    });
    return originalMethod.apply(this, args);
  };
}

class UserService {
  @validate
  createUser(@required name: string, age?: number) {
    return { name, age };
  }
}

const service = new UserService();
service.createUser("Alice"); // 正常执行
service.createUser(undefined); // 抛出错误（参数 0 为必填）

装饰器的执行顺序

当多个装饰器作用于同一目标时，执行顺序遵循从内到外、从下到上：

• 同一行的装饰器：从右到左执行。

• 不同行的装饰器：从上到下定义，从下到上执行。

function log1(target: any, key: string) {
  console.log("log1");
}
function log2(target: any, key: string) {
  console.log("log2");
}

class Example {
  @log1
  @log2 // 先执行 log2，再执行 log1
  method() {}
}

// 输出：log2 → log1

不同类型装饰器的执行顺序：参数装饰器 → 方法 / 访问器 / 属性装饰器 → 类装饰器

装饰器工厂（Decorator Factories）

装饰器工厂是一个返回装饰器函数的函数，用于为装饰器传递参数（解决装饰器本身无法直接接收参数的问题）。

// 带参数的日志装饰器
function logWithPrefix(prefix: string) {
  // 返回实际的装饰器函数
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
      console.log(`[${prefix}] 调用 ${propertyKey}`);
      return originalMethod.apply(this, args);
    };
  };
}

class Test {
  @logWithPrefix("INFO") // 传递参数
  doSomething() {}
}

new Test().doSomething(); // 输出：[INFO] 调用 doSomething