Паттерны проектирования на TypeScript
Паттерны проектирования — это проверенные решения в разработке программного обеспечения, которые помогают нам писать поддерживаемый и расширяемый код.
Система типов TypeScript позволяет реализовать многие классические паттерны проектирования типобезопасным образом.
SVG-диаграмма: классификация паттернов проектирования
Зачем нам нужны паттерны проектирования?
Паттерны проектирования — это обобщённый предшественниками опыт организации кода, позволяющий решать распространённые проблемы проектирования ПО.
Использование паттернов проектирования делает код проще для понимания и поддержки, а также облегчает командную работу.
Система типов 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)
Отделить построение сложного объекта от его представления, чтобы один и тот же процесс построения мог создавать разные представления.
Пример
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:Алгоритмы можно заменять.
- Внедрение зависимостей:Ослабляет связанность зависимостей.
Другие расширенияСовет:Понимание и применение паттернов проектирования на практике может помочь вам писать более элегантный и удобный в сопровождении код.