TypeScript Decorators
Dekoratoren sind ein experimentelles Feature von TypeScript.
Sie ermöglichen Entwicklern, zusätzliche Funktionalität zu Klassen, Methoden, Eigenschaften oder Parametern hinzuzufügen, ohne die ursprüngliche Klasse zu ändern.
Ein Dekorator ist im Wesentlichen eine Funktion, die zur Laufzeit aufgerufen werden kann, um das Verhalten des Zielobjekts zu ändern.
SVG-Diagramm: Dekorator-TypenEinführung in Dekoratoren
Dekoratoren verwenden das `@`-Symbol als syntaktischen Zucker und können an Klassen, Methoden, Accessoren, Eigenschaften oder Parameter angehängt werden.
Dieses Muster wird häufig in der Framework-Entwicklung verwendet; zum Beispiel nutzen Angular, TypeORM usw. Dekoratoren umfassend, um Dependency Injection, Datenvalidierung und andere Funktionen zu implementieren.
Hinweis:Dekoratoren sind derzeit ein experimentelles Feature und müssen in tsconfig.json explizit aktiviert werden. Wenn Sie sie in der Produktion verwenden, bestätigen Sie bitte, dass das Projekt experimentelle Features unterstützt.
Konfiguration zum Aktivieren von Dekoratoren
Bevor Sie Dekoratoren verwenden, müssen Sie die relevanten Compiler-Optionen in der TypeScript-Konfigurationsdatei tsconfig.json aktivieren.
tsconfig.json-Konfiguration
"compilerOptions": {
// Dekorator-Syntax aktivieren
"experimentalDecorators": true,
// Dekorator-Metadaten aktivieren (verwendet für Dependency-Injection-Frameworks)
"emitDecoratorMetadata": true
}
}
Parameter description:
- experimentalDecorators:Aktiviert die Unterstützung der Dekorator-Syntax; dies ist eine Voraussetzung für die Verwendung von Dekoratoren.
- emitDecoratorMetadata:Erzeugt Dekorator-Metadaten im kompilierten JavaScript zur Verwendung durch Dependency-Injection-Frameworks.
Klassendekoratoren
Klassen-Dekoratoren werden auf den Klassenkonstruktor angewendet und können die Klassendefinition ändern oder zusätzliche Verarbeitungslogik hinzufügen.
Ein Klassen-Dekorator erhält einen Parameter: den Konstruktor der Zielklasse.
Grundlegende Verwendung von Klassendekoratoren
// Der Parameter target ist der Konstruktor der dekorierten Klasse
function sealed(target: Function) {
// Gib den Namen der Klasse aus, auf die der Dekorator angewendet wird
console.log("Dekorator angewendet auf: " + target.name);
// Object.seal verwenden, um den Konstruktor und den Prototyp zu sperren
// Das Hinzufügen oder Entfernen von Eigenschaften zur Laufzeit verhindern
Object.seal(target);
Object.seal(target.prototype);
}
// Die @-Syntax verwenden, um den Dekorator auf die Klasse anzuwenden
@sealed
class Person {
name: string;
constructor(name: string) {
this.name = name;
}
}
// Eine Instanz zum Testen erstellen
var person = new Person("EXAMPLE");
console.log("Created: " + person.name);
// Versuch, eine neue Eigenschaft hinzuzufügen (wird verhindert, weil die Klasse versiegelt ist)
// person.age = 25; // schlägt stillschweigend fehl
Ausgabe:
装饰器 applied to: Person 创建: EXAMPLE
Erklärung:
Klassendekoratoren werden zur Klassendefinitionszeit ausgeführt und typischerweise verwendet, um das Klassenverhalten zu ändern, Metadaten hinzuzufügen oder AOP (aspektorientierte Programmierung) zu implementieren.
Methodendekoratoren
Methodendekoratoren werden auf Klassenmethoden angewendet und können den Eigenschaftsdeskriptor der Methode ändern.
Ein Methodendekorator empfängt drei Parameter: das Zielobjekt, den Eigenschaftsnamen und den Eigenschaftsdeskriptor.
Grundlegende Verwendung von Methodendekoratoren
// Eine Dekoratorfunktion zurückgeben
function enumerable(value: boolean) {
// Gibt eine Dekoratorfunktion zurück, die drei Parameter entgegennimmt
return function (
target: any, // Das Prototypobjekt der enthaltenden Klasse
propertyKey: string, // Der Methodenname
descriptor: PropertyDescriptor // Der Eigenschaftsdeskriptor
) {
// Das aufzählbare Attribut der Eigenschaft ändern
// false bedeutet, dass die Methode nicht aufzählbar ist
descriptor.enumerable = value;
};
}
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
// Den Dekorator anwenden, um die Methode als nicht aufzählbar festzulegen
@enumerable(false)
greet() {
return "Hallo, " + this.greeting;
}
}
var g = new Greeter("Welt");
// Prüfen, ob die greet-Methode aufzählbar ist
console.log("Methode aufzählbar: " + g.propertyIsEnumerable("greet"));
// Über die Eigenschaften des Objekts iterieren
for (var key in g) {
console.log("Eigenschaften: " + key);
}
Ausgabe:
方法可枚举: false
Tipp:PropertyDescriptor enthält Attribute wie enumerable, configurable, writable und value, die nach Bedarf geändert werden können.
Accessor-Dekoratoren
Accessor-Dekoratoren werden auf Getter- und Setter-Methoden einer Klasse angewendet.
Ähnlich wie Methodendekoratoren können Accessor-Dekoratoren auch den Property-Descriptor ändern.
Verwendung von Accessor-Dekoratoren
function configurable(value: boolean) {
return function (
target: any,
propertyKey: string,
descriptor: PropertyDescriptor
) {
// Ändere das configurable-Attribut der Eigenschaft
// false bedeutet, dass der Accessor nicht rekonfiguriert oder gelöscht werden kann
descriptor.configurable = value;
};
}
class Point {
private _x: number = 0;
private _y: number = 0;
// Verwende den Dekorator, um den Getter zu sperren
@configurable(false)
get x() {
return this._x;
}
@configurable(false)
get y() {
return this._y;
}
set x(value: number) {
this._x = value;
}
set y(value: number) {
this._y = value;
}
}
var point = new Point();
point.x = 10;
point.y = 20;
console.log("Koordinaten: (" + point.x + ", " + point.y + ")");
Erklärung:
Accessor-Dekoratoren können nicht gleichzeitig auf den Getter und Setter derselben Eigenschaft angewendet werden; es kann nur einer von beiden gewählt werden.
Eigenschaftsdekoratoren
Eigenschaftsdekoratoren werden auf Eigenschaftsdefinitionen einer Klasse angewendet.
Ein Eigenschaftsdekorator empfängt zwei Parameter: das Zielobjekt und den Eigenschaftsnamen.
Verwendung von Eigenschaftsdekoratoren
function format(formatString: string) {
return function (
target: any, // Das Prototypobjekt der Klasse
propertyKey: string // Der Eigenschaftsname
) {
// Metadaten auf dem Zielobjekt speichern
// Verwende propertyKey + "_format" als Schlüsselnamen, um Konflikte zu vermeiden
Object.defineProperty(target, propertyKey + "_format", {
value: formatString,
writable: false,
enumerable: false,
configurable: true
});
};
}
class User {
// Den Property-Decorator anwenden, um das Datumsformat festzulegen
@format("YYYY-MM-DD")
birthDate: string;
constructor(birthDate: string) {
this.birthDate = birthDate;
}
}
var user = new User("1990-01-01");
console.log("Geburtsdatum: " + user.birthDate);
// Zugriff auf die gespeicherten Metadaten
console.log("Datumsformat: " + (user as any).birthDate_format);
Ausgabe:
出生日期: 1990-01-01 日期格式: YYYY-MM-DD
Parameter-Dekoratoren
Parameter-Dekoratoren werden auf Parameter von Klassenmethoden angewendet und können Metadaten oder Marker zu Parametern hinzufügen.
Ein Parameter-Dekorator empfängt drei Parameter: das Zielobjekt, den Methodennamen und den Index des Parameters in der Funktion.
Verwendung von Parameter-Dekoratoren
// Wird verwendet, um Parameterinformationen aufzuzeichnen oder eine Validierung durchzuführen
function logParameter(
target: any, // Das Prototypobjekt der Klasse
propertyKey: string, // Der Methodenname
parameterIndex: number // Die Indexposition des Parameters in der Funktion (beginnend bei 0)
) {
console.log("Parameter-Dekorator: " + propertyKey +
" " + (parameterIndex + 1) + ". Parameter");
}
class Greeter {
greeting: string;
constructor(greeting: string) {
this.greeting = greeting;
}
// Verwende die @-Syntax vor dem Parameter, um den Dekorator anzuwenden
greet(@logParameter name: string) {
return this.greeting + ", " + name;
}
}
var greeter = new Greeter("Hallo");
greeter.greet("BEISPIEL");
Ausgabe:
参数装饰器: greet 第 1 个参数
Dekorator-Fabrik
Eine Dekorator-Fabrik ist eine Funktion, die eine Dekorator-Funktion zurückgibt.
Durch eine Dekorator-Fabrik lassen sich beim Anwenden des Dekorators benutzerdefinierte Parameter übergeben, was eine flexiblere Konfiguration ermöglicht.
Decorator-Factory für farbige Logs
function color(colorCode: string) {
// colorCode ist der Farbcode in ANSI-Escape-Sequenzen
// Zum Beispiel: 34 = Blau, 31 = Rot, 32 = Grün
return function (
target: any,
propertyKey: string,
descriptor: PropertyDescriptor
) {
// Originalmethode speichern
var originalMethod = descriptor.value;
// Methode überschreiben, um Farbe hinzuzufügen
descriptor.value = function (...args: any[]) {
// Originalmethode aufrufen, um den Rückgabewert zu erhalten
var result = originalMethod.apply(this, args);
// In einer Terminalumgebung Farbe zur Ausgabe hinzufügen
// ANSI-Escape-Sequenz-Format: \x1b[Farbcode m Inhalt \x1b[0m
return "\x1b[" + colorCode + "m" + result + "\x1b[0m";
};
};
}
class Logger {
// Decorator-Factory verwenden, blauen Farbcode 34 übergeben
@color("34")
log(message: string): string {
return message;
}
@color("31")
error(message: string): string {
return message;
}
@color("32")
success(message: string): string {
return message;
}
}
var logger = new Logger();
console.log(logger.log("Dies ist ein blaues Log"));
console.log(logger.error("Dies ist ein roter Fehler"));
console.log(logger.success("Dies ist ein grüner Erfolg"));
Run result:
This is blue log (displayed as blue in terminal) This is red error (displayed as red in terminal) This is green success (displayed as green in terminal)
Erklärung:Die Decorator-Factory ist die in der Praxis am häufigsten verwendete Form. Sie ermöglicht die Übergabe von Parametern beim Anwenden von Decorators und ermöglicht so die Konfiguration.
Ausführungsreihenfolge von Decorators
Wenn eine Klasse mehrere Decorators hat, folgt die Ausführungsreihenfolge bestimmten Regeln.
- Decorators werden von unten nach oben angewendet
- Mehrere Decorators desselben Typs werden von rechts nach links ausgeführt
- Parameter-Decorators werden vor Methoden-Decorators ausgeführt
Beispiel für die Ausführungsreihenfolge von Decorators
function first() {
console.log("erster Decorator");
return function (target: any) {
console.log("erste Decorator-Funktion");
};
}
function second() {
console.log("zweiter Dekorator");
return function (target: any) {
console.log("zweite Dekoratorfunktion");
};
}
@first()
@second()
class MyClass {
name: string;
}
var obj = new MyClass();
Run result:
second 装饰器 first 装饰器 second 装饰器函数 first 装饰器函数
Erklärung:
Die Definitionen der Dekoratorfunktionen werden zuerst ausgeführt (console.log), dann werden die Dekoratorfunktionen in der Reihenfolge von unten nach oben ausgeführt.
Anwendungsszenarien aus der Praxis
Dekoratoren haben in realen Projekten ein breites Spektrum an Anwendungsszenarien.
Protokollierung
Methodenaufrufe automatisch protokollieren.
Beispiel
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
var originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
console.log("Methode wird aufgerufen: " + propertyKey + ", Parameter: " + JSON.stringify(args));
var result = originalMethod.apply(this, args);
console.log("Rückgabewert der Methode: " + JSON.stringify(result));
return result;
};
}
class MathService {
@log
add(a: number, b: number): number {
return a + b;
}
@log
multiply(a: number, b: number): number {
return a * b;
}
}
var math = new MathService();
console.log("Berechnungsergebnis: " + math.add(5, 3));
Run result:
调用方法: add,参数: [5,3] 方法返回: 8 计算结果: 8
Berechtigungsprüfung
Implementieren Sie die Berechtigungsprüfung auf Methodenebene.
Beispiel
var currentUser = { role: "admin" };
// Berechtigungsdekorator
function requireRole(role: string) {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
var originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
if (currentUser.role !== role) {
console.log("Unzureichende Berechtigungen, kann nicht ausgeführt werden " + propertyKey);
return null;
}
return originalMethod.apply(this, args);
};
};
}
class AdminService {
@requireRole("admin")
deleteUser(id: number): string {
return "Benutzer " + id + " erfolgreich gelöscht";
}
@requireRole("admin")
viewUser(id: number): string {
return "Benutzer anzeigen " + id;
}
}
var admin = new AdminService();
console.log(admin.viewUser(1));
console.log(admin.deleteUser(1));
// Simuliere normalen Benutzer
currentUser = { role: "user" };
console.log(admin.deleteUser(2));
Run result:
查看用户 1 删除用户 1 成功 权限不足,无法执行 deleteUser
Hinweise
- Experimentelles Feature:Decorators sind ein _Stage-3_-Vorschlag von ECMAScript und derzeit noch ein experimentelles Feature
- Compiler-Optionen:experimentalDecorators muss aktiviert werden
- Typdefinitionen:Für vollständige Typunterstützung ist eine neuere Version von TypeScript erforderlich
- Debugging-Hinweis:Decorators werden zur Kompilierungszeit ausgeführt, und einige Debugging-Tools ordnen Quellcode-Positionen möglicherweise nicht korrekt zu
Empfehlung:Wenn Decorators in einem Projekt verwendet werden, wird empfohlen, dedizierte Decorator-Hilfsklassen oder Funktionsbibliotheken zu erstellen, um die Definition und Verwendung von Decorators einheitlich zu verwalten.
Zusammenfassung
TypeScript-Decorators bieten eine leistungsstarke Metaprogrammierungsfähigkeit.
- Klassen-Decorators:Ändern die Klasse selbst, können verwendet werden, um Metadaten hinzuzufügen, Klassen zu sperren usw.
- Methoden-Decorators:Ändern Methodeneigenschaften, können für Protokollierung, Validierung usw. verwendet werden.
- Accessor-Decorators:Ändern Getter/Setter, steuern die Konfigurierbarkeit von Eigenschaften
- Eigenschafts-Decorators:Fügen Metadaten zu Eigenschaften hinzu
- Parameter-Decorators:Markieren oder validieren Methodenparameter
- Decorator-Fabrik:Flexiblere Decorator-Konfiguration durch Parametrisierung erreichen
Weitere Erweiterungen