TypeScript-Entwurfsmuster
Entwurfsmuster sind bewährte Lösungen in der Softwareentwicklung, die uns helfen, wartbaren und erweiterbaren Code zu schreiben.
Das Typsystem von TypeScript ermöglicht es, viele klassische Entwurfsmuster typsicher zu implementieren.
SVG-Diagramm: Klassifizierung von Entwurfsmustern
Warum brauchen wir Entwurfsmuster?
Entwurfsmuster sind von Vorgängern zusammengefasste Erfahrungen zur Codeorganisation und können häufige Probleme im Softwareentwurf lösen.
Die Verwendung von Entwurfsmustern macht Code leichter verständlich und wartbar und erleichtert außerdem die Teamzusammenarbeit.
Das Typsystem von TypeScript macht diese Muster robuster, und Fehler können zur Kompilierzeit entdeckt werden.
Konzept:Entwurfsmuster sind wiederverwendbare Lösungen für häufige Probleme im Softwareentwurf und eine Zusammenfassung von Erfahrungen im Code-Design.
Singleton-Muster (Singleton)
Stellen Sie sicher, dass eine Klasse nur eine Instanz hat, und bieten Sie einen globalen Zugriffspunkt.
Beispiel
class Singleton {
// Singleton-Instanz speichern
private static instance: Singleton;
private static _data: string = "";
// Privater Konstruktor, um externe Instanziierung zu verhindern
Privater Konstruktor() {}
// Statische Methode zum Abrufen der Singleton-Instanz
public static getInstance(): Singleton {
if (!Singleton.instance) {
Singleton.instance = new Singleton();
}
return Singleton.instance;
}
// Daten setzen
public setData(data: string): void {
Singleton._data = data;
}
// Daten abrufen
public getData(): string {
return Singleton._data;
}
}
// Singleton-Muster testen
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
// Überprüfen, ob es dieselbe Instanz ist
console.log("Ist dieselbe Instanz: " + (instance1 === instance2));
instance1.setData("Hello Singleton");
console.log("Data: " + instance2.getData());
Ausgabe:
是同一实例: true 数据: Hello Singleton
Privater Konstruktor:Durch das Setzen des Konstruktors auf privat wird die externe Instanziierung mit `new` verhindert.
Fabrikmuster (Factory)
Verwende eine generische Factory, um typsichere Objektinstanzen zu erstellen.
Beispiel
interface Product {
name: string;
price: number;
getDescription(): string;
}
// Konkretes Produkt: Elektronik
class ElectronicProduct implements Product {
constructor(
public name: string,
public price: number,
public warranty: number
) {}
getDescription(): string {
return `${this.name} - ¥${this.price} (warranty${this.warranty}year)`;
}
}
// Konkretes Produkt: Kleidung
class ClothingProduct implements Product {
constructor(
public name: string,
public price: number,
public size: string
) {}
getDescription(): string {
return `${this.name} - ¥${this.price} (size: ${this.size})`;
}
}
// Fabrikklasse
class ProductFactory {
// Generische Fabrikmethode
static create<T extends Product>(
type: new (...args: any[]) => T,
...args: any[]
): T {
return new type(...args);
}
}
// Verwenden Sie die Factory, um Produkte zu erstellen
const laptop = ProductFactory.create(ElectronicProduct, Laptop, 5999, 2);
const shirt = ProductFactory.create(ClothingProduct, T-shirt, 199, "L");
console.log(laptop.getDescription());
console.log(shirt.getDescription());
Generische Factory:Verwenden Sie generische Einschränkungen, um sicherzustellen, dass ein konkreter Produkttyp zurückgegeben wird.
Decorator-Muster (Decorator)
Verwenden Sie Decorators, um Objekten dynamisch Funktionalität hinzuzufügen.
Beispiel
interface Coffee {
getCost(): number;
getDescription(): string;
}
// Grundlegende Kaffee-Implementierung
class SimpleCoffee implements Coffee {
getCost(): number {
return 10;
}
getDescription(): string {
return Coffee;
}
}
// Dekorator-Basisklasse
abstract class CoffeeDecorator implements Coffee {
constructor(protected coffee: Coffee) {}
getCost(): number {
return this.coffee.getCost();
}
getDescription(): string {
return this.coffee.getDescription();
}
}
// Milch-Dekorator
class MilkDecorator extends CoffeeDecorator {
getCost(): number {
return this.coffee.getCost() + 2;
}
getDescription(): string {
return this.coffee.getDescription() + ", Milk";
}
}
// Zucker-Dekorator
class SugarDecorator extends CoffeeDecorator {
getCost(): number {
return this.coffee.getCost() + 1;
}
getDescription(): string {
return this.coffee.getDescription() + ", Sugar";
}
}
// Dekorator verwenden
let coffee: Coffee = new SimpleCoffee();
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());
coffee = new MilkDecorator(coffee);
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());
coffee = new SugarDecorator(coffee);
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());
Dekorator:Er kann dynamisch neue Funktionalität hinzufügen, ohne die ursprüngliche Klasse zu ändern, und ist ein experimentelles Feature von TypeScript.
Beobachter-Muster (Observer)
Definiere eine Eins-zu-viele-Abhängigkeit zwischen Objekten; wenn sich der Zustand eines Objekts ändert, werden alle abhängigen Objekte benachrichtigt.
Beispiel
interface Observer {
update(message: string): void;
}
// Subjekt-Schnittstelle
interface Subject {
attach(observer: Observer): void;
detach(observer: Observer): void;
notify(): void;
}
// Konkretes Subjekt: Nachrichtenzentrale
class MessageCenter implements Subject {
private observers: Observer[] = [];
private message: string = "";
// Beobachter hinzufügen
attach(observer: Observer): void {
this.observers.push(observer);
}
// Beobachter entfernen
detach(observer: Observer): void {
const index = this.observers.indexOf(observer);
if (index > -1) {
this.observers.splice(index, 1);
}
}
// Alle Beobachter benachrichtigen
notify(): void {
for (const observer of this.observers) {
observer.update(this.message);
}
}
// Nachricht veröffentlichen
publish(message: string): void {
this.message = message;
console.log("Nachricht veröffentlichen: " + message);
this.notify();
}
}
// Konkreter Beobachter: Benutzer
class UserObserver implements Observer {
constructor(public name: string) {}
update(message: string): void {
console.log(`[${this.name}]receivesMessage: ${message}`);
}
}
// Verwende das Beobachter-Muster
const center = new MessageCenter();
const user1 = new UserObserver("Benutzer A");
const user2 = new UserObserver("Benutzer B");
center.attach(user1);
center.attach(user2);
center.publish("Neues Feature ist online!");
Entkopplung:Das Beobachter-Muster implementiert lose Kopplung zwischen Subjekten und Beobachtern.
Strategiemuster (Strategie)
Definiere eine Reihe von Algorithmen, kapsle sie einzeln und mache sie austauschbar.
Beispiel
interface PaymentStrategy {
pay(amount: number): void;
}
// WeChat-Pay-Strategie
class WechatPayStrategy implements PaymentStrategy {
pay(amount: number): void {
console.log(`WeChat Pay wird verwendet ¥${amount}`);
}
}
// Alipay-Strategie
class AlipayStrategy implements PaymentStrategy {
pay(amount: number): void {
console.log(`Alipay wird verwendet ¥${amount}`);
}
}
// Bankkartenstrategie
class CardPayStrategy implements PaymentStrategy {
pay(amount: number): void {
console.log(`Bankkarte verwenden ¥${amount}`);
}
}
// Zahlungskontext
class PaymentContext {
private strategy: PaymentStrategy;
constructor(strategy: PaymentStrategy) {
this.strategy = strategy;
}
// Zahlungsstrategie festlegen
setStrategy(strategy: PaymentStrategy): void {
this.strategy = strategy;
}
// Zahlung ausführen
pay(amount: number): void {
this.strategy.pay(amount);
}
}
// Strategiemuster verwenden
const context = new PaymentContext(new WechatPayStrategy());
context.pay(100);
context.setStrategy(new AlipayStrategy());
context.pay(200);
context.setStrategy(new CardPayStrategy());
context.pay(300);
Algorithmuswechsel:Das Strategiemuster kann Algorithmen zur Laufzeit wechseln und bietet große Flexibilität.
Dependency Injection
Abhängigkeiten über den Konstruktor injizieren; es ist eines der am häufigsten verwendeten Muster in TypeScript.
Beispiel
interface Logger {
log(message: string): void;
}
interface Storage {
save(key: string, data: any): void;
}
// Konkrete Service-Implementierung
class ConsoleLogger implements Logger {
log(message: string): void {
console.log("[Protokoll]: " + message);
}
}
class LocalStorage implements Storage {
save(key: string, data: any): void {
console.log(`Speichere ${key}: ${JSON.`stringify(data)}`);
localStorage.setItem(key, JSON.stringify(data));
}
}
// Dienst mit Dependency Injection
class UserService {
constructor(
private logger: Logger,
private storage: Storage
) {}
createUser(name: string): void {
const user = { name, createdAt: new Date() };
this.logger.log("Benutzer erstellen: " + name);
this.storage.save("user", user);
}
}
// Abhängigkeit injizieren
const logger = new ConsoleLogger();
const storage = new LocalStorage();
const userService = new UserService(logger, storage);
userService.createUser("Alice");
Abhängigkeitsumkehr:Abhängigkeitsinjektion stellt sicher, dass High-Level-Module nicht von Low-Level-Modulen abhängen, sondern von abstrakten Schnittstellen.
Builder-Muster (Builder)
Trenne die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass derselbe Konstruktionsprozess verschiedene Darstellungen erzeugen kann.
Beispiel
interface Builder<T> {
build(): T;
}
// Komplexes Objekt: Benutzerkonfiguration
interface UserConfig {
name: string;
email: string;
age?: number;
role?: string;
theme?: string;
}
// Benutzerkonfigurations-Builder
class UserConfigBuilder implements Builder<UserConfig> {
private config: Partial<UserConfig> = {};
setName(name: string): this {
this.config.name = name;
return this;
}
setEmail(email: string): this {
this.config.email = email;
return this;
}
setAge(age: number): this {
this.config.age = age;
return this;
}
setRole(role: string): this {
this.config.role = role;
return this;
}
setTheme(theme: string): this {
this.config.theme = theme;
return this;
}
build(): UserConfig {
if (!this.config.name || !this.config.email) {
throw new Error("Name und E-Mail sind erforderlich");
}
return this.config as UserConfig;
}
}
// Verwende den Builder
const builder = new UserConfigBuilder();
const config = builder
.setName("Alice")
.setEmail("alice@example.com")
.setAge(25)
.setRole("admin")
.setTheme("dark")
.build();
console.log("Benutzerkonfiguration:", JSON.stringify(config, null, 2));
Verkettete Aufrufe:Das Builder-Muster unterstützt verkettete Aufrufe, wodurch der Code prägnanter und lesbarer wird.
Hinweise
- Typsicherheit:Verwende das Typsystem von TypeScript, um die Sicherheit von Pattern-Implementierungen zu gewährleisten.
- Übertreibe es nicht:Verwende Design Patterns nur, wenn sie wirklich benötigt werden.
- Halte es einfach:Bevorzuge einfache Lösungen.
- Teamkonsens:Die Verwendung von Entwurfsmustern im Team vereinheitlichen.
Best Practice:Entwurfsmuster sind Werkzeuge, kein Dogma. Wählen Sie das Muster, das zur tatsächlichen Situation des Projekts passt.
Zusammenfassung
Entwurfsmuster sind wichtige Erfahrungswerte bei der Codeorganisation.
- Singleton-Muster:Stellen Sie sicher, dass eine Klasse nur eine Instanz hat
- Factory-Muster:Den Prozess der Objekterstellung kapseln
- Decorator-Muster:Funktionalität dynamisch hinzufügen
- Observer-Muster:Eine Eins-zu-viele-Abhängigkeitsbeziehung
- Strategie-Muster:Algorithmen sind austauschbar
- Dependency Injection:Abhängigkeiten entkoppeln
Andere ErweiterungenEmpfehlung:Das Verständnis und die Anwendung von Entwurfsmustern in der Praxis können Ihnen helfen, eleganteren und wartbareren Code zu schreiben.