• 装饰器
  • 介绍
  • 装饰器
    • 装饰器工厂
    • 装饰器组合
    • 装饰器求值
    • 类装饰器
    • 方法装饰器
    • 访问器装饰器
    • 属性装饰器
    • 参数装饰器
    • 元数据

    装饰器

    介绍

    随着TypeScript和ES6里引入了类，在一些场景下我们需要额外的特性来支持标注或修改类及其成员。 装饰器（Decorators）为我们在类的声明及成员上通过元编程语法添加标注提供了一种方式。 Javascript里的装饰器目前处在 建议征集的第二阶段，但在TypeScript里已做为一项实验性特性予以支持。

    注意  装饰器是一项实验性特性，在未来的版本中可能会发生改变。

    若要启用实验性的装饰器特性，你必须在命令行或tsconfig.json里启用experimentalDecorators编译器选项：

    命令行:

    1. tsc --target ES5 --experimentalDecorators

    tsconfig.json:

    1. {
    2.     "compilerOptions": {
    3.         "target": "ES5",
    4.         "experimentalDecorators": true
    5.     }
    6. }

    装饰器

    装饰器是一种特殊类型的声明，它能够被附加到类声明，方法， 访问符，属性或参数上。 装饰器使用 @expression这种形式，expression求值后必须为一个函数，它会在运行时被调用，被装饰的声明信息做为参数传入。

    例如，有一个@sealed装饰器，我们会这样定义sealed函数：

    1. function sealed(target) {
    2.     // do something with "target" ...
    3. }
    注意  后面类装饰器小节里有一个更加详细的例子。

    装饰器工厂

    如果我们要定制一个修饰器如何应用到一个声明上，我们得写一个装饰器工厂函数。 装饰器工厂就是一个简单的函数，它返回一个表达式，以供装饰器在运行时调用。

    我们可以通过下面的方式来写一个装饰器工厂函数：

    1. function color(value: string) { // 这是一个装饰器工厂
    2.     return function (target) { //  这是装饰器
    3.         // do something with "target" and "value"...
    4.     }
    5. }
    注意  下面方法装饰器小节里有一个更加详细的例子。

    装饰器组合

    多个装饰器可以同时应用到一个声明上，就像下面的示例：

    • 书写在同一行上： 
    1. @f @g x
    • 书写在多行上： 
    1. @f
    2. @g
    3. x

    当多个装饰器应用于一个声明上，它们求值方式与复合函数相似。在这个模型下，当复合f和g时，复合的结果(f ∘ g)(x)等同于f(g(x))。

    同样的，在TypeScript里，当多个装饰器应用在一个声明上时会进行如下步骤的操作：

    • 由上至下依次对装饰器表达式求值。
    • 求值的结果会被当作函数，由下至上依次调用。
      如果我们使用装饰器工厂的话，可以通过下面的例子来观察它们求值的顺序：
    1. function f() {
    2.     console.log("f(): evaluated");
    3.     return function (target, propertyKey: string, descriptor: PropertyDescriptor) {
    4.         console.log("f(): called");
    5.     }
    6. }
    8. function g() {
    9.     console.log("g(): evaluated");
    10.     return function (target, propertyKey: string, descriptor: PropertyDescriptor) {
    11.         console.log("g(): called");
    12.     }
    13. }
    15. class C {
    16.     @f()
    17.     @g()
    18.     method() {}
    19. }

    在控制台里会打印出如下结果：

    1. f(): evaluated
    2. g(): evaluated
    3. g(): called
    4. f(): called

    装饰器求值

    类中不同声明上的装饰器将按以下规定的顺序应用：

    • 参数装饰器，然后依次是方法装饰器，访问符装饰器，或属性装饰器应用到每个实例成员。
    • 参数装饰器，然后依次是方法装饰器，访问符装饰器，或属性装饰器应用到每个静态成员。
    • 参数装饰器应用到构造函数。
    • 类装饰器应用到类。

    类装饰器

    类装饰器在类声明之前被声明（紧靠着类声明）。 类装饰器应用于类构造函数，可以用来监视，修改或替换类定义。 类装饰器不能用在声明文件中( .d.ts)，也不能用在任何外部上下文中（比如declare的类）。

    类装饰器表达式会在运行时当作函数被调用，类的构造函数作为其唯一的参数。

    如果类装饰器返回一个值，它会使用提供的构造函数来替换类的声明。

    注意 如果你要返回一个新的构造函数，你必须注意处理好原来的原型链。 在运行时的装饰器调用逻辑中 不会为你做这些。

    下面是使用类装饰器(@sealed)的例子，应用在Greeter类：

    1. @sealed
    2. class Greeter {
    3.     greeting: string;
    4.     constructor(message: string) {
    5.         this.greeting = message;
    6.     }
    7.     greet() {
    8.         return "Hello, " + this.greeting;
    9.     }
    10. }

    我们可以这样定义@sealed装饰器：

    1. function sealed(constructor: Function) {
    2.     Object.seal(constructor);
    3.     Object.seal(constructor.prototype);
    4. }

    当@sealed被执行的时候，它将密封此类的构造函数和原型。(注：参见Object.seal)

    下面是一个重载构造函数的例子。

    1. function classDecorator<T extends {new(...args:any[]):{}}>(constructor:T) {
    2.     return class extends constructor {
    3.         newProperty = "new property";
    4.         hello = "override";
    5.     }
    6. }
    8. @classDecorator
    9. class Greeter {
    10.     property = "property";
    11.     hello: string;
    12.     constructor(m: string) {
    13.         this.hello = m;
    14.     }
    15. }
    17. console.log(new Greeter("world"));

    方法装饰器

    方法装饰器声明在一个方法的声明之前（紧靠着方法声明）。 它会被应用到方法的 属性描述符上，可以用来监视，修改或者替换方法定义。 方法装饰器不能用在声明文件( .d.ts)，重载或者任何外部上下文（比如declare的类）中。

    方法装饰器表达式会在运行时当作函数被调用，传入下列3个参数：

    • 对于静态成员来说是类的构造函数，对于实例成员是类的原型对象。
    • 成员的名字。
    • 成员的属性描述符。
    注意  如果代码输出目标版本小于ES5，属性描述符将会是undefined。

    如果方法装饰器返回一个值，它会被用作方法的属性描述符。

    注意  如果代码输出目标版本小于ES5返回值会被忽略。

    下面是一个方法装饰器（@enumerable）的例子，应用于Greeter类的方法上：

    1. class Greeter {
    2.     greeting: string;
    3.     constructor(message: string) {
    4.         this.greeting = message;
    5.     }
    7.     @enumerable(false)
    8.     greet() {
    9.         return "Hello, " + this.greeting;
    10.     }
    11. }

    我们可以用下面的函数声明来定义@enumerable装饰器：

    1. function enumerable(value: boolean) {
    2.     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    3.         descriptor.enumerable = value;
    4.     };
    5. }

    这里的@enumerable(false)是一个装饰器工厂。 当装饰器 @enumerable(false)被调用时，它会修改属性描述符的enumerable属性。

    访问器装饰器

    访问器装饰器声明在一个访问器的声明之前（紧靠着访问器声明）。 访问器装饰器应用于访问器的 属性描述符并且可以用来监视，修改或替换一个访问器的定义。 访问器装饰器不能用在声明文件中（.d.ts），或者任何外部上下文（比如 declare的类）里。

    注意  TypeScript不允许同时装饰一个成员的get和set访问器。取而代之的是，一个成员的所有装饰的必须应用在文档顺序的第一个访问器上。这是因为，在装饰器应用于一个属性描述符时，它联合了get和set访问器，而不是分开声明的。

    访问器装饰器表达式会在运行时当作函数被调用，传入下列3个参数：

    • 对于静态成员来说是类的构造函数，对于实例成员是类的原型对象。
    • 成员的名字。
    • 成员的属性描述符。
    注意  如果代码输出目标版本小于ES5，Property Descriptor将会是undefined。

    如果访问器装饰器返回一个值，它会被用作方法的属性描述符。

    注意  如果代码输出目标版本小于ES5返回值会被忽略。

    下面是使用了访问器装饰器（@configurable）的例子，应用于Point类的成员上：

    1. class Point {
    2.     private _x: number;
    3.     private _y: number;
    4.     constructor(x: number, y: number) {
    5.         this._x = x;
    6.         this._y = y;
    7.     }
    9.     @configurable(false)
    10.     get x() { return this._x; }
    12.     @configurable(false)
    13.     get y() { return this._y; }
    14. }

    我们可以通过如下函数声明来定义@configurable装饰器：

    1. function configurable(value: boolean) {
    2.     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    3.         descriptor.configurable = value;
    4.     };
    5. }

    属性装饰器

    属性装饰器声明在一个属性声明之前（紧靠着属性声明）。 属性装饰器不能用在声明文件中（.d.ts），或者任何外部上下文（比如 declare的类）里。

    属性装饰器表达式会在运行时当作函数被调用，传入下列2个参数：

    • 对于静态成员来说是类的构造函数，对于实例成员是类的原型对象。
    • 成员的名字。
    注意  属性描述符不会做为参数传入属性装饰器，这与TypeScript是如何初始化属性装饰器的有关。 因为目前没有办法在定义一个原型对象的成员时描述一个实例属性，并且没办法监视或修改一个属性的初始化方法。返回值也会被忽略。因此，属性描述符只能用来监视类中是否声明了某个名字的属性。

    我们可以用它来记录这个属性的元数据，如下例所示：

    1. class Greeter {
    2.     @format("Hello, %s")
    3.     greeting: string;
    5.     constructor(message: string) {
    6.         this.greeting = message;
    7.     }
    8.     greet() {
    9.         let formatString = getFormat(this, "greeting");
    10.         return formatString.replace("%s", this.greeting);
    11.     }
    12. }

    然后定义@format装饰器和getFormat函数：

    1. import "reflect-metadata";
    3. const formatMetadataKey = Symbol("format");
    5. function format(formatString: string) {
    6.     return Reflect.metadata(formatMetadataKey, formatString);
    7. }
    9. function getFormat(target: any, propertyKey: string) {
    10.     return Reflect.getMetadata(formatMetadataKey, target, propertyKey);
    11. }

    这个@format("Hello, %s")装饰器是个 装饰器工厂。 当 @format("Hello, %s")被调用时，它添加一条这个属性的元数据，通过reflect-metadata库里的Reflect.metadata函数。 当 getFormat被调用时，它读取格式的元数据。

    注意  这个例子需要使用reflect-metadata库。 查看 元数据了解reflect-metadata库更详细的信息。

    参数装饰器

    参数装饰器声明在一个参数声明之前（紧靠着参数声明）。 参数装饰器应用于类构造函数或方法声明。 参数装饰器不能用在声明文件（.d.ts），重载或其它外部上下文（比如 declare的类）里。

    参数装饰器表达式会在运行时当作函数被调用，传入下列3个参数：

    • 对于静态成员来说是类的构造函数，对于实例成员是类的原型对象。
    • 成员的名字。
    • 参数在函数参数列表中的索引。
    注意  参数装饰器只能用来监视一个方法的参数是否被传入。

    参数装饰器的返回值会被忽略。

    下例定义了参数装饰器（@required）并应用于Greeter类方法的一个参数：

    1. class Greeter {
    2.     greeting: string;
    4.     constructor(message: string) {
    5.         this.greeting = message;
    6.     }
    8.     @validate
    9.     greet(@required name: string) {
    10.         return "Hello " + name + ", " + this.greeting;
    11.     }
    12. }

    然后我们使用下面的函数定义 @required 和 @validate 装饰器：

    1. import "reflect-metadata";
    3. const requiredMetadataKey = Symbol("required");
    5. function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {
    6.     let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];
    7.     existingRequiredParameters.push(parameterIndex);
    8.     Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);
    9. }
    11. function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor<Function>) {
    12.     let method = descriptor.value;
    13.     descriptor.value = function () {
    14.         let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);
    15.         if (requiredParameters) {
    16.             for (let parameterIndex of requiredParameters) {
    17.                 if (parameterIndex >= arguments.length || arguments[parameterIndex] === undefined) {
    18.                     throw new Error("Missing required argument.");
    19.                 }
    20.             }
    21.         }
    23.         return method.apply(this, arguments);
    24.     }
    25. }

    @required装饰器添加了元数据实体把参数标记为必需的。 @validate装饰器把greet方法包裹在一个函数里在调用原先的函数前验证函数参数。

    注意  这个例子使用了reflect-metadata库。 查看 元数据了解reflect-metadata库的更多信息。

    元数据

    一些例子使用了reflect-metadata库来支持实验性的metadata API。 这个库还不是ECMAScript (JavaScript)标准的一部分。 然而，当装饰器被ECMAScript官方标准采纳后，这些扩展也将被推荐给ECMAScript以采纳。

    你可以通过npm安装这个库：

    1. npm i reflect-metadata --save

    TypeScript支持为带有装饰器的声明生成元数据。 你需要在命令行或 tsconfig.json里启用emitDecoratorMetadata编译器选项。

    Command Line:

    1. tsc --target ES5 --experimentalDecorators --emitDecoratorMetadata

    tsconfig.json:

    1. {
    2.     "compilerOptions": {
    3.         "target": "ES5",
    4.         "experimentalDecorators": true,
    5.         "emitDecoratorMetadata": true
    6.     }
    7. }

    当启用后，只要reflect-metadata库被引入了，设计阶段添加的类型信息可以在运行时使用。

    如下例所示：

    1. import "reflect-metadata";
    3. class Point {
    4.     x: number;
    5.     y: number;
    6. }
    8. class Line {
    9.     private _p0: Point;
    10.     private _p1: Point;
    12.     @validate
    13.     set p0(value: Point) { this._p0 = value; }
    14.     get p0() { return this._p0; }
    16.     @validate
    17.     set p1(value: Point) { this._p1 = value; }
    18.     get p1() { return this._p1; }
    19. }
    21. function validate<T>(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) {
    22.     let set = descriptor.set;
    23.     descriptor.set = function (value: T) {
    24.         let type = Reflect.getMetadata("design:type", target, propertyKey);
    25.         if (!(value instanceof type)) {
    26.             throw new TypeError("Invalid type.");
    27.         }
    28.         set(value);
    29.     }
    30. }

    TypeScript编译器可以通过@Reflect.metadata装饰器注入设计阶段的类型信息。 你可以认为它相当于下面的TypeScript： 

    1. class Line {
    2.     private _p0: Point;
    3.     private _p1: Point;
    5.     @validate
    6.     @Reflect.metadata("design:type", Point)
    7.     set p0(value: Point) { this._p0 = value; }
    8.     get p0() { return this._p0; }
    10.     @validate
    11.     @Reflect.metadata("design:type", Point)
    12.     set p1(value: Point) { this._p1 = value; }
    13.     get p1() { return this._p1; }
    14. }
    注意  装饰器元数据是个实验性的特性并且可能在以后的版本中发生破坏性的改变（breaking changes）。