Breaking News: Grepper is joining You.com. Read the official announcement!

design patterns typescript

Sivasubramaniyam V answered on July 19, 2023 Popularity 9/10 Helpfulness 1/10

answer design patterns typescript

design patterns typescript

Comment

Singleton Pattern:
The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance.

class Singleton {
  private static instance: Singleton;

  private constructor() {}

  public static getInstance(): Singleton {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton();
    }
    return Singleton.instance;
  }
}

const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2); // Output: true




Factory Pattern:
The Factory pattern is used to create objects without exposing the instantiation logic to the client. It provides an interface for creating objects of a superclass but allows subclasses to alter the type of objects that will be created.

abstract class Product {
  abstract getInfo(): string;
}

class ConcreteProductA extends Product {
  getInfo(): string {
    return 'Product A';
  }
}

class ConcreteProductB extends Product {
  getInfo(): string {
    return 'Product B';
  }
}

class ProductFactory {
  createProduct(type: 'A' | 'B'): Product {
    if (type === 'A') {
      return new ConcreteProductA();
    } else if (type === 'B') {
      return new ConcreteProductB();
    }
    throw new Error('Invalid product type.');
  }
}

const factory = new ProductFactory();
const productA = factory.createProduct('A');
const productB = factory.createProduct('B');

console.log(productA.getInfo()); // Output: "Product A"
console.log(productB.getInfo()); // Output: "Product B"


Observer Pattern:
The Observer pattern allows an object (subject) to publish changes to its state and notify its dependents (observers) about those changes.

interface Observer {
  update(message: string): void;
}

class Subject {
  private observers: Observer[] = [];

  addObserver(observer: Observer): void {
    this.observers.push(observer);
  }

  removeObserver(observer: Observer): void {
    this.observers = this.observers.filter((obs) => obs !== observer);
  }

  notifyObservers(message: string): void {
    this.observers.forEach((observer) => observer.update(message));
  }
}

class ConcreteObserver implements Observer {
  update(message: string): void {
    console.log(`Received update: ${message}`);
  }
}

const subject = new Subject();
const observer1 = new ConcreteObserver();
const observer2 = new ConcreteObserver();

subject.addObserver(observer1);
subject.addObserver(observer2);
subject.notifyObservers('Hello observers!');

Popularity 9/10 Helpfulness 1/10 Language typescript

Source: Grepper

Tags: design-patterns typescript

Link to this answer
Share Copy Link

Contributed on Jul 19 2023

Sivasubramaniyam V

0 Answers Avg Quality 2/10

design patterns typescript

Contents

More Related Answers

design patterns typescript

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.