JavaScript装饰器从基础到实战教程_Javascript

装饰器（decorator）是javascript中一种声明式的语法特性，用于在不修改原始代码的情况下，动态扩展类、方法、属性或参数的行为。它本质上是一个函数，通过@符号附加到目标上，让代码更优雅、可维护。本文将从基础概念入手，逐步讲解装饰器的类型、用法、进阶技巧及实战场景。

一、装饰器基础概念

1.1 什么是装饰器？

装饰器是一种特殊函数，接收目标对象（类、方法、属性等）作为参数，返回修改后的目标或新的描述符。其核心价值是分离关注点——将日志记录、权限验证、性能监控等功能从业务代码中剥离，通过装饰器“装饰”到目标上。

1.2 装饰器的语法

装饰器使用@符号，紧跟装饰器函数名，放置在目标声明前：

@decorator
class myclass {} // 类装饰器
class myclass {
  @decorator
  mymethod() {} // 方法装饰器
  @decorator
  myproperty; // 属性装饰器
}

等价于：

class myclass {}
myclass = decorator(myclass) || myclass; // 类装饰器
myclass.prototype.mymethod = decorator(myclass.prototype, 'mymethod', object.getownpropertydescriptor(myclass.prototype, 'mymethod')) || myclass.prototype.mymethod; // 方法装饰器

1.3 装饰器的执行时机

装饰器在编译阶段执行（es6模块加载时），而非运行时。例如：

function logclass(target) {
  console.log('类装饰器执行'); // 编译阶段输出
  target.prototype.timestamp = new date();
}
@logclass
class myclass {}
// 实例化时不会再次执行装饰器
const instance = new myclass();
console.log(instance.timestamp); // 输出编译阶段的日期

二、装饰器的主要类型

装饰器可分为五大类，分别作用于不同的目标：

2.1 类装饰器

作用：修改类的构造函数或原型，添加静态属性/方法或实例属性/方法。
参数：类的构造函数（target）。
示例：为类添加静态属性和实例属性。

function addstaticproperty(staticprop, value) {
  return function(target) {
    target[staticprop] = value; // 添加静态属性
  };
}
function addinstanceproperty(instanceprop, initialvalue) {
  return function(target) {
    target.prototype[instanceprop] = initialvalue; // 添加实例属性
  };
}
@addstaticproperty('version', '1.0.0')
@addinstanceproperty('timestamp', new date())
class myclass {}
console.log(myclass.version); // 输出: 1.0.0
const instance = new myclass();
console.log(instance.timestamp); // 输出: 编译阶段的日期

2.2 方法装饰器

作用：修改方法的描述符（value、writable等），实现日志、权限、性能监控等功能。
参数：

target：静态方法为类的构造函数，实例方法为类的原型；
propertykey：方法名；
descriptor：方法描述符（包含value、writable等属性）。
示例：记录方法调用日志。

function logmethod(target, propertykey, descriptor) {
  const originalmethod = descriptor.value;
  descriptor.value = function(...args) {
    console.log(`调用方法 ${propertykey}，参数: ${json.stringify(args)}`);
    const result = originalmethod.apply(this, args);
    console.log(`方法 ${propertykey} 返回: ${result}`);
    return result;
  };
  return descriptor;
}
class calculator {
  @logmethod
  add(a, b) {
    return a + b;
  }
}
const calc = new calculator();
calc.add(2, 3); 
// 输出: 
// 调用方法 add，参数: [2,3]
// 方法 add 返回: 5

2.3 属性装饰器

作用：修改属性的描述符（如writable设为false实现只读），或通过object.defineproperty定义属性的getter/setter。
参数：

target：静态属性为类的构造函数，实例属性为类的原型；
propertykey：属性名。
示例：实现属性只读。

function readonly(target, propertykey) {
  object.defineproperty(target, propertykey, {
    writable: false, // 设为不可写
    configurable: false // 设为不可配置（防止后续修改）
  });
}
class person {
  @readonly
  name = 'john';
}
const person = new person();
person.name = 'jane'; // 严格模式下报错：cannot assign to read only property 'name'
console.log(person.name); // 输出: john

2.4 访问器装饰器

作用：修改属性的getter或setter方法，实现数据格式化、验证等功能。
参数：与方法装饰器相同（target、propertykey、descriptor）。
示例：将属性值转为大写。

function capitalize(target, propertykey, descriptor) {
  const originalgetter = descriptor.get;
  descriptor.get = function() {
    return originalgetter.call(this).touppercase(); // 转为大写
  };
  return descriptor;
}
class user {
  constructor(name) {
    this._name = name;
  }
  @capitalize
  get name() {
    return this._name;
  }
}
const user = new user('john');
console.log(user.name); // 输出: john

2.5 参数装饰器

作用：为方法参数添加元数据（如参数名、验证规则），常用于框架中的依赖注入或参数校验。
参数：

target：类的原型（实例方法）或构造函数（静态方法）；
propertykey：方法名；
parameterindex：参数的索引（从0开始）。
示例：记录参数索引。

function logparameter(target, propertykey, parameterindex) {
  const existingparameters = target[propertykey + 'parameters'] || [];
  existingparameters.push(parameterindex);
  target[propertykey + 'parameters'] = existingparameters;
}
class userservice {
  getuser(@logparameter id, @logparameter name) {
    return { id, name };
  }
}
const userservice = new userservice();
userservice.getuser(1, 'john');
console.log(userservice.prototype.getuserparameters); // 输出: [0, 1]

三、装饰器的高级用法

3.1 装饰器工厂：传递参数

装饰器本身是静态的，若需动态配置，可通过装饰器工厂（返回装饰器函数的函数）实现。
示例：带参数的权限装饰器。

function checkpermission(requiredrole) {
  return function(target, propertykey, descriptor) {
    const originalmethod = descriptor.value;
    descriptor.value = function(...args) {
      const userrole = this.userrole; // 假设实例上有userrole属性
      if (userrole === requiredrole) {
        return originalmethod.apply(this, args);
      } else {
        throw new error(`无权限：需要${requiredrole}角色`);
      }
    };
    return descriptor;
  };
}
class adminpanel {
  userrole = 'admin';
  @checkpermission('admin')
  deleteuser() {
    console.log('用户已删除');
  }
}
const panel = new adminpanel();
panel.deleteuser(); // 输出: 用户已删除
const userpanel = new adminpanel();
userpanel.userrole = 'user';
userpanel.deleteuser(); // 报错: 无权限：需要admin角色

3.2 多个装饰器的执行顺序

多个装饰器按从外到内的顺序应用（声明顺序），但从内到外执行（执行顺序）。
示例：

function dec1(target, propertykey, descriptor) {
  console.log('装饰器1应用');
  return descriptor;
}
function dec2(target, propertykey, descriptor) {
  console.log('装饰器2应用');
  return descriptor;
}
class example {
  @dec1
  @dec2
  method() {}
}
// 输出:
// 装饰器2应用
// 装饰器1应用

3.3 组合装饰器：简化重复代码

通过高阶函数组合多个装饰器，减少重复代码。
示例：组合日志和性能监控装饰器。

function composedecorators(...decorators) {
  return function(target, propertykey, descriptor) {
    return decorators.reduceright((desc, decorator) => decorator(target, propertykey, desc), descriptor);
  };
}
function logmethod(target, propertykey, descriptor) {
  const originalmethod = descriptor.value;
  descriptor.value = function(...args) {
    console.log(`调用方法 ${propertykey}`);
    return originalmethod.apply(this, args);
  };
  return descriptor;
}
function measuretime(target, propertykey, descriptor) {
  const originalmethod = descriptor.value;
  descriptor.value = function(...args) {
    const start = date.now();
    const result = originalmethod.apply(this, args);
    console.log(`方法 ${propertykey} 执行时间: ${date.now() - start}ms`);
    return result;
  };
  return descriptor;
}
const logandmeasure = composedecorators(logmethod, measuretime);
class dataprocessor {
  @logandmeasure
  processdata(data) {
    // 模拟耗时操作
    for (let i = 0; i < 1e6; i++) {}
    return data;
  }
}
const processor = new dataprocessor();
processor.processdata([1, 2, 3]);
// 输出:
// 调用方法 processdata
// 方法 processdata 执行时间: 5ms

四、装饰器的实战场景

4.1 日志记录

通过装饰器自动记录方法的调用信息和返回值，无需手动添加console.log。

function logmethod(target, propertykey, descriptor) {
  const originalmethod = descriptor.value;
  descriptor.value = function(...args) {
    console.log(`[log] 调用 ${propertykey}，参数: ${json.stringify(args)}`);
    const result = originalmethod.apply(this, args);
    console.log(`[log] ${propertykey} 返回: ${result}`);
    return result;
  };
  return descriptor;
}
class loggerexample {
  @logmethod
  greet(name) {
    return `hello, ${name}！`;
  }
}
const logger = new loggerexample();
logger.greet('alice');
// 输出:
// [log] 调用 greet，参数: ["alice"]
// [log] greet 返回: hello, alice！

4.2 权限验证

通过装饰器在方法执行前检查用户权限，避免重复编写权限逻辑。

function haspermission(requiredpermission) {
  return function(target, propertykey, descriptor) {
    const originalmethod = descriptor.value;
    descriptor.value = function(...args) {
      const userpermissions = this.permissions || []; // 假设实例上有permissions属性
      if (userpermissions.includes(requiredpermission)) {
        return originalmethod.apply(this, args);
      } else {
        throw new error(`无权限：需要${requiredpermission}`);
      }
    };
    return descriptor;
  };
}
class documentmanager {
  permissions = ['read'];
  @haspermission('write')
  editdocument(content) {
    console.log('文档已编辑');
  }
}
const manager = new documentmanager();
manager.editdocument('新内容'); // 报错: 无权限：需要write
manager.permissions.push('write');
manager.editdocument('新内容'); // 输出: 文档已编辑

4.3 性能监控

通过装饰器监控方法的执行时间，快速定位性能瓶颈。

function measureperformance(target, propertykey, descriptor) {
  const originalmethod = descriptor.value;
  descriptor.value = function(...args) {
    const start = performance.now();
    const result = originalmethod.apply(this, args);
    const end = performance.now();
    console.log(`[perf] 方法 ${propertykey} 执行时间: ${end - start}ms`);
    return result;
  };
  return descriptor;
}
class heavycalculation {
  @measureperformance
  calculatefactorial(n) {
    return n <= 1 ? 1 : n * this.calculatefactorial(n - 1);
  }
}
const calculator = new heavycalculation();
calculator.calculatefactorial(10); // 输出: [perf] 方法 calculatefactorial 执行时间: 1ms

4.4 自动绑定this

通过装饰器自动绑定方法的this，避免在回调中丢失this。

function autobind(target, propertykey, descriptor) {
  const originalmethod = descriptor.value;
  descriptor.value = function(...args) {
    return originalmethod.apply(this, args);
  };
  return descriptor;
}
class button {
  constructor(text) {
    this.text = text;
    this.handleclick = this.handleclick.bind(this); // 传统方式
  }
  @autobind
  handleclick() {
    console.log(`按钮文本: ${this.text}`);
  }
}
const button = new button('click me');
const clickhandler = button.handleclick;
clickhandler(); // 输出: 按钮文本: click me（无需手动绑定）

五、注意事项

装饰器的执行顺序：多个装饰器按从外到内应用，从内到外执行。例如@a @b等同于a(b(target))，但执行顺序是b先于a。
不能装饰函数：函数存在变量提升，装饰器可能在函数声明前执行，导致意外结果。建议使用类或箭头函数。
兼容性问题：装饰器是es提案，需通过babel（@babel/plugin-proposal-decorators）或typescript（experimentaldecorators）转译。
保持单一职责：每个装饰器只做一件事（如日志、权限），避免复杂逻辑，提高可维护性。

六、总结

装饰器是javascript中强大的语法糖，通过声明式的方式扩展类、方法、属性的功能，让代码更清晰、可维护。本文从基础概念讲起，覆盖了类、方法、属性、访问器、参数五大类装饰器，以及装饰器工厂、组合装饰器等高级用法，最后结合实战场景演示了日志、权限、性能监控等常见应用。掌握装饰器，能让你写出更优雅、更模块化的代码。

到此这篇关于javascript装饰器从基础到实战教程的文章就介绍到这了,更多相关javascript装饰器内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！