装饰器

[toc]

学习目标

  • 了解装饰器语法，学会使用装饰器对类进行扩展
  • 清楚装饰器执行顺序
  • 了解元数据以及针对装饰器的元数据编程

什么是装饰器

装饰器-Decorators 在 TypeScript 中是一种可以在不修改类代码的基础上通过添加标注的方式来对类型进行扩展的一种方式

  • 减少代码量
  • 提高代码扩展性、可读性和维护性

在 TypeScript 中，装饰器只能在类中使用

装饰器语法

装饰器的使用极其的简单

  • 装饰器本质就是一个函数
  • 通过特定语法在特定的位置调用装饰器函数即可对数据（类、方法、甚至参数等）进行扩展

启用装饰器特性

  • experimentalDecorators: true
  1. // 装饰器函数
  2. function log(target: Function, type: string, descriptor: PropertyDescriptor) {
  3.     let value = descriptor.value;
  5.     descriptor.value = function(a: number, b: number) {
  6.         let result = value(a, b);
  7.         console.log('日志：', {
  8.             type,
  9.             a,
  10.             b,
  11.             result
  12.         })
  13.         return result;
  14.     }
  15. }
  17. // 原始类
  18. class M {
  19.     @log
  20.     static add(a: number, b: number) {
  21.         return a + b;
  22.     }
  23.     @log
  24.     static sub(a: number, b: number) {
  25.         return a - b;
  26.     }
  27. }
  29. let v1 = M.add(1, 2);
  30. console.log(v1);
  31. let v2 = M.sub(1, 2);
  32. console.log(v2);

装饰器

装饰器 是一个函数，它可以通过 @装饰器函数 这种特殊的语法附加在 类、方法 、访问符、属性、参数 上，对它们进行包装，然后返回一个包装后的目标对象（类、方法 、访问符、属性、参数 ），装饰器工作在类的构建阶段，而不是使用阶段

  1. function 装饰器1() {}
  2. ...
  4. @装饰器1
  5. class MyClass {
  7.   @装饰器2
  8.   a: number;
  10.   @装饰器3
  11.   static property1: number;
  13.   @装饰器4
  14.   get b() { 
  15.     return 1; 
  16.   }
  18.   @装饰器5
  19.   static get c() {
  20.     return 2;
  21.   }
  23.   @装饰器6
  24.   public method1(@装饰器5 x: number) {
  25.     //
  26.   }
  28.   @装饰器7
  29.   public static method2() {}
  30. }

类装饰器

目标

  • 应用于类的构造函数

参数

  • 第一个参数（也只有一个参数）

    • 类的构造函数作为其唯一的参数

方法装饰器

目标

  • 应用于类的方法上

参数

  • 第一个参数

    • 静态方法：类的构造函数
    • 实例方法：类的原型对象

  • 第二个参数

    • 方法名称

  • 第三个参数

    • 方法描述符对象

属性装饰器

目标

  • 应用于类的属性上

参数

  • 第一个参数

    • 静态方法：类的构造函数
    • 实例方法：类的原型对象

  • 第二个参数

    • 属性名称

访问器装饰器

目标

  • 应用于类的访问器（getter、setter）上

参数

  • 第一个参数

    • 静态方法：类的构造函数
    • 实例方法：类的原型对象

  • 第二个参数

    • 属性名称

  • 第三个参数

    • 方法描述符对象

参数装饰器

目标

  • 应用在参数上

参数

  • 第一个参数

    • 静态方法：类的构造函数
    • 实例方法：类的原型对象

  • 第二个参数

    • 方法名称

  • 第三个参数

    • 参数在函数参数列表中的索引

装饰器执行顺序

实例装饰器

  1.     属性 => 访问符 => 参数 => 方法

静态装饰器

  1.     属性 => 访问符 => 参数 => 方法

类

  1.     类

装饰器工厂

如果我们需要给装饰器执行过程中传入一些参数的时候，就可以使用装饰器工厂来实现

  1. // 装饰器函数
  2. function log(callback: Function) {
  3.       return function(target: Function, type: string, descriptor: PropertyDescriptor) {
  4.               let value = descriptor.value;
  6.         descriptor.value = function(a: number, b: number) {
  7.             let result = value(a, b);
  8.             callback({
  9.                 type,
  10.                 a,
  11.                 b,
  12.                 result
  13.             });
  14.             return result;
  15.         }
  16.     }
  17. }
  19. // 原始类
  20. class M {
  21.     @log(function(result: any) {
  22.           console.log('日志：', result)
  23.     })
  24.     static add(a: number, b: number) {
  25.         return a + b;
  26.     }
  27.     @log(function(result: any) {
  28.           localStorage.setItem('log', JSON.stringify(result));
  29.     })
  30.     static sub(a: number, b: number) {
  31.         return a - b;
  32.     }
  33. }
  35. let v1 = M.add(1, 2);
  36. console.log(v1);
  37. let v2 = M.sub(1, 2);
  38. console.log(v2);

元数据

在 装饰器 函数中 ，我们可以拿到 类、方法 、访问符、属性、参数 的基本信息，如它们的名称，描述符 等，但是我们想获取更多信息就需要通过另外的方式来进行：元数据

什么是元数据？

元数据 ：用来描述数据的数据，在我们的程序中，对象、类 等都是数据，它们描述了某种数据，另外还有一种数据，它可以用来描述 对象、类，这些用来描述数据的数据就是 元数据

比如一首歌曲本身就是一组数据，同时还有一组用来描述歌曲的歌手、格式、时长的数据，那么这组数据就是歌曲数据的元数据

使用 reflect-metadata

https://www.npmjs.com/package/reflect-metadata

首先，需要安装 reflect-metadata

  1. npm install reflect-metadata

定义元数据

我们可以 类、方法 等数据定义元数据

  • 元数据会被附加到指定的 类、方法 等数据之上，但是又不会影响 类、方法 本身的代码

设置

Reflect.defineMetadata(metadataKey, metadataValue, target, propertyKey)

  • metadataKey：meta 数据的 key
  • metadataValue：meta 数据的 值
  • target：meta 数据附加的目标
  • propertyKey：对应的 property key

调用方式

  • 通过 Reflect.defineMetadata 方法调用来添加 元数据

  • 通过 @Reflect.metadata 装饰器来添加 元数据

  1. import "reflect-metadata"
  3. @Reflect.metadata("n", 1)
  4. class A {
  5.     @Reflect.metadata("n", 2)
  6.     public static method1() {
  7.     }
  9.       @Reflect.metadata("n", 4)
  10.       public method2() {
  11.     }
  12. }
  14. // or
  15. Reflect.defineMetadata('n', 1, A);
  16. Reflect.defineMetadata('n', 2, A, 'method1');
  18. let obj = new A();
  19. Reflect.defineMetadata('n', 3, obj);
  20. Reflect.defineMetadata('n', 4, obj, 'method2');
  22. console.log(Reflect.getMetadata('n', A));
  23. console.log(Reflect.getMetadata('n', A, ));

获取

Reflect.getMetadata(metadataKey, target, propertyKey)

参数的含义与 defineMetadata 对应

使用元数据的 log 装饰器

  1. import "reflect-metadata"
  3. function L(type = 'log') {
  4.       return function(target: any) {
  5.           Reflect.defineMetadata("type", type, target);
  6.     }
  7. }
  8. // 装饰器函数
  9. function log(callback: Function) {
  10.       return function(target: any, name: string, descriptor: PropertyDescriptor) {
  11.               let value = descriptor.value;
  13.           let type = Reflect.getMetadata("type", target);
  15.         descriptor.value = function(a: number, b: number) {
  16.             let result = value(a, b);
  17.               if (type === 'log') {
  18.                   console.log('日志：', {
  19.                   name,
  20.                   a,
  21.                   b,
  22.                   result
  23.                 })
  24.             }
  25.               if (type === 'storage') {
  26.                 localStorage.setItem('storageLog', JSON.stringify({
  27.                   name,
  28.                   a,
  29.                   b,
  30.                   result
  31.                 }));
  32.             }
  33.             return result;
  34.         }
  35.     }
  36. }
  38. // 原始类
  39. @L('log')
  40. class M {
  41.     @log
  42.     static add(a: number, b: number) {
  43.         return a + b;
  44.     }
  45.     @log
  46.     static sub(a: number, b: number) {
  47.         return a - b;
  48.     }
  49. }
  51. let v1 = M.add(1, 2);
  52. console.log(v1);
  53. let v2 = M.sub(1, 2);
  54. console.log(v2);

使用 emitDecoratorMetadata

在 tsconfig.json 中有一个配置 emitDecoratorMetadata，开启该特性，typescript 会在编译之后自动给 类、方法 、访问符、属性、参数 添加如下几个元数据

  • design:type：被装饰目标的类型

    • 成员属性：属性的标注类型
    • 成员方法：Function 类型

  • design:paramtypes

    • 成员方法：方法形参列表的标注类型
    • 类：构造函数形参列表的标注类型

  • design:returntype

    • 成员方法：函数返回值的标注类型
  1. import "reflect-metadata"
  3. function n(target: any) {
  4. }
  5. function f(name: string) {
  6.     return function(target: any, propertyKey: string, descriptor: any) {
  7.           console.log( 'design type', Reflect.getMetadata('design:type', target, propertyKey) );
  8.         console.log( 'params type', Reflect.getMetadata('design:paramtypes', target, propertyKey) );
  9.         console.log( 'return type', Reflect.getMetadata('design:returntype', target, propertyKey) );
  10.     }
  11. }
  12. function m(target: any, propertyKey: string) {
  14. }
  16. @n
  17. class B {
  18.     @m
  19.     name: string;
  21.     constructor(a: string) {
  23.     }
  25.     @f('')
  26.     method1(a: string, b: string) {
  27.         return 'a'
  28.     }
  29. }

编译后

  1. __decorate([
  2.     m,
  3.     __metadata("design:type", String)
  4. ], B.prototype, "name", void 0);
  5. __decorate([
  6.     f(''),
  7.     __metadata("design:type", Function),
  8.     __metadata("design:paramtypes", [String, String]),
  9.     __metadata("design:returntype", void 0)
  10. ], B.prototype, "method1", null);
  11. B = __decorate([
  12.     n,
  13.     __metadata("design:paramtypes", [String])
  14. ], B);