Паттерны проектирования на TypeScript

Паттерны проектирования — это проверенные решения в разработке программного обеспечения, которые помогают нам писать поддерживаемый и расширяемый код.

Система типов TypeScript позволяет реализовать многие классические паттерны проектирования типобезопасным образом.


SVG-диаграмма: классификация паттернов проектирования Background Title Design Pattern Classification Creational Creational Patterns Factory | Singleton | Builder Structural Structural Patterns Decorator | Adapter | Proxy Behavioral Behavioral Patterns Observer | Strategy | Command TypeScript-specific TypeScript-specific Patterns Type-safe dependency injection | Generic factory | Conditional type selection Advantages TypeScript advantages: compile-time type checking + IDE IntelliSense + runtime performance

Зачем нам нужны паттерны проектирования?

Паттерны проектирования — это обобщённый предшественниками опыт организации кода, позволяющий решать распространённые проблемы проектирования ПО.

Использование паттернов проектирования делает код проще для понимания и поддержки, а также облегчает командную работу.

Система типов TypeScript делает эти паттерны более надёжными, а ошибки можно обнаружить на этапе компиляции.

Концепция:Паттерны проектирования — это переиспользуемые решения распространённых проблем проектирования ПО и обобщение опыта проектирования кода.


Паттерн Одиночка (Singleton)

Гарантировать наличие у класса только одного экземпляра и предоставить глобальную точку доступа.

Пример

// Шаблон одиночка: гарантировать наличие только одного экземпляра
class Singleton {
    // Сохранить экземпляр синглтона
    private static instance: Singleton;
    private static _data: string = "";

    // Приватный конструктор, чтобы предотвратить внешнее создание экземпляров
    private constructor() {}

    // Статический метод для получения экземпляра синглтона
    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }

    // Установить данные
    public setData(data: string): void {
        Singleton._data = data;
    }

    // Получить данные
    public getData(): string {
        return Singleton._data;
    }
}

// Тестирование паттерна одиночка
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

// Убедиться, что это тот же экземпляр
console.log("Это тот же экземпляр: " + (instance1 === instance2));

instance1.setData("Hello Singleton");
console.log("Data: " + instance2.getData());

Вывод:

是同一实例: true
数据: Hello Singleton

Приватный конструктор:Установка конструктора как приватного предотвращает внешнее создание экземпляров с помощью `new`.


Паттерн Фабрика (Factory)

Используйте обобщённую фабрику для создания типобезопасных экземпляров объектов.

Пример

// Определить интерфейс продукта
interface Product {
    name: string;
    price: number;
    getDescription(): string;
}

// Конкретный продукт: электроника
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)`;
    }
}

// Конкретный продукт: одежда
class ClothingProduct implements Product {
    constructor(
        public name: string,
        public price: number,
        public size: string
    ) {}

    getDescription(): string {
        return `${this.name} - ¥${this.price} (size: ${this.size})`;
    }
}

// Фабричный класс
class ProductFactory {
    // Обобщённый фабричный метод
    static create<T extends Product>(
        type: new (...args: any[]) => T,
        ...args: any[]
    ): T {
        return new type(...args);
    }
}

// Используйте фабрику для создания продуктов
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());

Обобщённая фабрика:Используйте обобщённые ограничения, чтобы гарантировать возврат конкретного типа продукта.


Паттерн «Декоратор» (Decorator)

Используйте декораторы для динамического добавления функциональности объектам.

Пример

// Базовый интерфейс кофе
interface Coffee {
    getCost(): number;
    getDescription(): string;
}

// Базовая реализация кофе
class SimpleCoffee implements Coffee {
    getCost(): number {
        return 10;
    }

    getDescription(): string {
        return Coffee;
    }
}

// Базовый класс декоратора
abstract class CoffeeDecorator implements Coffee {
    constructor(protected coffee: Coffee) {}

    getCost(): number {
        return this.coffee.getCost();
    }

    getDescription(): string {
        return this.coffee.getDescription();
    }
}

// Декоратор молока
class MilkDecorator extends CoffeeDecorator {
    getCost(): number {
        return this.coffee.getCost() + 2;
    }

    getDescription(): string {
        return this.coffee.getDescription() + ", Milk";
    }
}

// Декоратор сахара
class SugarDecorator extends CoffeeDecorator {
    getCost(): number {
        return this.coffee.getCost() + 1;
    }

    getDescription(): string {
        return this.coffee.getDescription() + ", Sugar";
    }
}

// Использование декоратора
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());

Декоратор:Он может динамически добавлять новую функциональность без изменения исходного класса и является экспериментальной функцией TypeScript.


Паттерн «Наблюдатель» (Observer)

Определяет зависимость «один ко многим» между объектами; когда состояние объекта изменяется, все зависимые уведомляются.

Пример

// Интерфейс наблюдателя
interface Observer {
    update(message: string): void;
}

// Интерфейс субъекта
interface Subject {
    attach(observer: Observer): void;
    detach(observer: Observer): void;
    notify(): void;
}

// Конкретный субъект: центр сообщений
class MessageCenter implements Subject {
    private observers: Observer[] = [];
    private message: string = "";

    // Добавить наблюдателя
    attach(observer: Observer): void {
        this.observers.push(observer);
    }

    // Удалить наблюдателя
    detach(observer: Observer): void {
        const index = this.observers.indexOf(observer);
        if (index > -1) {
            this.observers.splice(index, 1);
        }
    }

    // Оповестить всех наблюдателей
    notify(): void {
        for (const observer of this.observers) {
            observer.update(this.message);
        }
    }

    // Публикация сообщения
    publish(message: string): void {
        this.message = message;
        console.log("Публикация сообщения: " + message);
        this.notify();
    }
}

// Конкретный наблюдатель: пользователь
class UserObserver implements Observer {
    constructor(public name: string) {}

    update(message: string): void {
        console.log(`[${this.name}]receivesMessage: ${message}`);
    }
}

// Используйте паттерн «Наблюдатель»
const center = new MessageCenter();

const user1 = new UserObserver("Пользователь A");
const user2 = new UserObserver("Пользователь B");

center.attach(user1);
center.attach(user2);

center.publish("Новая функция уже доступна!");

Снижение связанности:Паттерн наблюдатель реализует слабую связанность между субъектами и наблюдателями.


Паттерн «Стратегия» (Strategy)

Определяет набор алгоритмов, инкапсулирует их по отдельности и делает взаимозаменяемыми.

Пример

// Интерфейс стратегии оплаты
interface PaymentStrategy {
    pay(amount: number): void;
}

// Стратегия WeChat Pay
class WechatPayStrategy implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Оплата через WeChat Pay ¥${amount}`);
    }
}

// Стратегия Alipay
class AlipayStrategy implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Оплата через Alipay ¥${amount}`);
    }
}

// Стратегия банковской карты
class CardPayStrategy implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Оплата банковской картой ¥${amount}`);
    }
}

// Контекст платежа
class PaymentContext {
    private strategy: PaymentStrategy;

    constructor(strategy: PaymentStrategy) {
        this.strategy = strategy;
    }

    // Установить стратегию платежа
    setStrategy(strategy: PaymentStrategy): void {
        this.strategy = strategy;
    }

    // Выполнить платеж
    pay(amount: number): void {
        this.strategy.pay(amount);
    }
}

// Использовать паттерн «стратегия»
const context = new PaymentContext(new WechatPayStrategy());
context.pay(100);

context.setStrategy(new AlipayStrategy());
context.pay(200);

context.setStrategy(new CardPayStrategy());
context.pay(300);

Переключение алгоритмов:Паттерн «стратегия» может переключать алгоритмы во время выполнения, обеспечивая большую гибкость.


Внедрение зависимостей

Внедряйте зависимости через конструктор; это один из наиболее часто используемых паттернов в TypeScript.

Пример

// Определить интерфейс сервиса
interface Logger {
    log(message: string): void;
}

interface Storage {
    save(key: string, data: any): void;
}

// Конкретная реализация сервиса
class ConsoleLogger implements Logger {
    log(message: string): void {
        console.log("[Лог]: " + message);
    }
}

class LocalStorage implements Storage {
    save(key: string, data: any): void {
        console.log(`Сохранить ${key}: ${JSON.`stringify(data)}`);
        localStorage.setItem(key, JSON.stringify(data));
    }
}

// Сервис с внедрением зависимостей
class UserService {
    constructor(
        private logger: Logger,
        private storage: Storage
    ) {}

    createUser(name: string): void {
        const user = { name, createdAt: new Date() };
        this.logger.log("Создание пользователя: " + name);
        this.storage.save("user", user);
    }
}

// Внедрение зависимости
const logger = new ConsoleLogger();
const storage = new LocalStorage();
const userService = new UserService(logger, storage);

userService.createUser("Alice");

Инверсия зависимостей:Внедрение зависимостей гарантирует, что модули высокого уровня не зависят от модулей низкого уровня, а зависят от абстрактных интерфейсов.


Паттерн «Строитель» (Builder)

Отделить построение сложного объекта от его представления, чтобы один и тот же процесс построения мог создавать разные представления.

Пример

// Интерфейс Builder
interface Builder<T> {
    build(): T;
}

// Сложный объект: конфигурация пользователя
interface UserConfig {
    name: string;
    email: string;
    age?: number;
    role?: string;
    theme?: string;
}

// Строитель конфигурации пользователя
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("Требуются имя и адрес электронной почты");
        }
        return this.config as UserConfig;
    }
}

// Используйте строитель
const builder = new UserConfigBuilder();
const config = builder
    .setName("Alice")
    .setEmail("alice@example.com")
    .setAge(25)
    .setRole("admin")
    .setTheme("dark")
    .build();

console.log("Конфигурация пользователя:", JSON.stringify(config, null, 2));

Цепочки вызовов:Паттерн строитель поддерживает цепочки вызовов, делая код более кратким и читаемым.


Примечания

  • Типобезопасность:Используйте систему типов TypeScript, чтобы обеспечить безопасность реализаций паттернов.
  • Не переусердствуйте:Используйте паттерны проектирования только тогда, когда это действительно необходимо.
  • Придерживайтесь простоты:Предпочитайте простые решения.
  • Консенсус команды:Унифицируйте использование паттернов проектирования внутри команды.

Лучшая практика:Паттерны проектирования — это инструменты, а не догма. Выбирайте паттерн, который соответствует реальной ситуации проекта.


Итог

Паттерны проектирования — это важный опыт в организации кода.

  • Паттерн Singleton:Гарантирует наличие у класса только одного экземпляра.
  • Паттерн Factory:Инкапсулирует процесс создания объектов.
  • Паттерн Decorator:Динамически добавляет функциональность.
  • Паттерн Observer:Зависимость «один ко многим».
  • Паттерн Strategy:Алгоритмы можно заменять.
  • Внедрение зависимостей:Ослабляет связанность зависимостей.

Совет:Понимание и применение паттернов проектирования на практике может помочь вам писать более элегантный и удобный в сопровождении код.

Другие расширения