Шаблоны проектирования — это важные инструменты разработки программного обеспечения, которые помогают решать типичные архитектурные проблемы и обеспечивают возможность повторного использования кода, удобство сопровождения и расширяемость. В этой статье блога мы рассмотрим различные шаблоны проектирования и покажем, как их реализовать с помощью TypeScript. Мы предоставим примеры кода и пояснения в разговорной форме, чтобы разработчикам было легче понять эти концепции и применить их в своих проектах.

1. Шаблон Singleton:
   Шаблон Singleton гарантирует, что класс имеет только один экземпляр, и предоставляет глобальную точку доступа к нему. Давайте возьмем пример класса Logger, к которому необходимо получить доступ из нескольких частей приложения.

class Logger {
  private static instance: Logger;
  private constructor() {
    // Initialize logger instance
  }
  public static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
    return Logger.instance;
  }
  public log(message: string): void {
    // Log the message
  }
}
const logger = Logger.getInstance();
logger.log("Hello, Singleton Pattern!");

1. Шаблон Factory:
   Шаблон Factory предоставляет интерфейс для создания объектов без указания их конкретных классов. Он инкапсулирует логику создания объектов, позволяя клиентам создавать объекты через общий интерфейс.

interface Product {
  // Common product interface
}
class ConcreteProductA implements Product {
  // Implementation of Product A
}
class ConcreteProductB implements Product {
  // Implementation of Product B
}
class ProductFactory {
  public createProduct(type: string): Product {
    if (type === "A") {
      return new ConcreteProductA();
    } else if (type === "B") {
      return new ConcreteProductB();
    } else {
      throw new Error("Invalid product type.");
    }
  }
}
const factory = new ProductFactory();
const productA = factory.createProduct("A");
const productB = factory.createProduct("B");

1. Шаблон «Наблюдатель».
   Шаблон «Наблюдатель» устанавливает связь «один ко многим» между объектами, при которой изменения в одном объекте автоматически отражаются в других зависимых объектах. Это способствует слабой связи между объектами.

interface Observer {
  update(): void;
}
class Subject {
  private observers: Observer[] = [];
  public attach(observer: Observer): void {
    this.observers.push(observer);
  }
  public detach(observer: Observer): void {
    const index = this.observers.indexOf(observer);
    if (index !== -1) {
      this.observers.splice(index, 1);
    }
  }
  public notify(): void {
    this.observers.forEach((observer) => {
      observer.update();
    });
  }
}
class ConcreteObserver implements Observer {
  public update(): void {
    // Handle the update
  }
}
const subject = new Subject();
const observerA = new ConcreteObserver();
const observerB = new ConcreteObserver();
subject.attach(observerA);
subject.attach(observerB);
// Trigger a notification
subject.notify();

1. Шаблон стратегии:
   Шаблон стратегии определяет семейство взаимозаменяемых алгоритмов и инкапсулирует каждый алгоритм в отдельный класс. Это позволяет выбирать алгоритмы во время выполнения.

interface Strategy {
  execute(): void;
}
class ConcreteStrategyA implements Strategy {
  public execute(): void {
    // Execute strategy A
  }
}
class ConcreteStrategyB implements Strategy {
  public execute(): void {
    // Execute strategy B
  }
}
class Context {
  private strategy: Strategy;
  public setStrategy(strategy: Strategy): void {
    this.strategy = strategy;
  }
  public executeStrategy(): void {
    this.strategy.execute();
  }
}
const context = new Context();
const strategyA = new ConcreteStrategyA();
const strategyB = new ConcreteStrategyB();
context.setStrategy(strategyA);
context.executeStrategy();
context.setStrategy(strategyB);
context.executeStrategy();

В этой статье блога мы рассмотрели лишь некоторые из множества шаблонов проектирования, которые можно реализовать с помощью TypeScript. Понимая и применяя эти шаблоны, разработчики могут повысить качество и удобство сопровождения своего кода. Мы рекомендуем вам изучить больше шаблонов проектирования и использовать их в своих проектах TypeScript для создания надежного и масштабируемого программного обеспечения.

Не забывайте применять эти шаблоны разумно, учитывая конкретные требования вашего проекта и придерживаясь лучших практик разработки программного обеспечения.