디자인 패턴 구현

interface Product {
  getName(): string;
}

class ProductA implements Product {
  getName(): string {
    return "Product A";
  }
}

class ProductB implements Product {
  getName(): string {
    return "Product B";
  }
}

abstract class Creator {
  protected abstract createProduct(): Product;

  describe(): string {
    const product = this.createProduct();
    return `Creator worked with ${product.getName()}`;
  }
}

class CreatorA extends Creator {
  protected createProduct(): Product {
    return new ProductA();
  }
}

class CreatorB extends Creator {
  protected createProduct(): Product {
    return new ProductB();
  }
}

for (const creator of [new CreatorA(), new CreatorB()]) {
  console.log(creator.describe());
}

Creator worked with Product A
Creator worked with Product B

class AppConfig {
  private static instance: AppConfig | undefined;

  private constructor(private data: string) {}

  static getInstance(data = "Default Data"): AppConfig {
    if (AppConfig.instance === undefined) {
      AppConfig.instance = new AppConfig(data);
    }
    return AppConfig.instance;
  }

  getData(): string {
    return this.data;
  }

  setData(data: string): void {
    this.data = data;
  }
}

const s1 = AppConfig.getInstance("First Data");
const s2 = AppConfig.getInstance("Second Data");
console.log(s1 === s2, s1.getData());

s2.setData("Updated Data");
console.log(s1.getData());

true First Data
Updated Data

class OldPaymentGateway {
  processOldPayment(amount: number, currency: string): boolean {
    console.log(`Old Gateway: Processing ${amount} ${currency} payment.`);
    return true;
  }
}

interface PaymentGateway {
  pay(amount: number): boolean;
}

class PaymentGatewayAdapter implements PaymentGateway {
  constructor(private oldGateway: OldPaymentGateway, private currency: string) {}

  pay(amount: number): boolean {
    return this.oldGateway.processOldPayment(amount, this.currency);
  }
}

class PaymentService {
  constructor(private gateway: PaymentGateway) {}

  makePayment(amount: number): void {
    const succeeded = this.gateway.pay(amount);
    console.log(succeeded ? "Payment completed." : "Payment failed.");
  }
}

new PaymentService(new PaymentGatewayAdapter(new OldPaymentGateway(), "USD")).makePayment(150);

Old Gateway: Processing 150 USD payment.
Payment completed.

interface StateObserver {
  update(state: number): void;
}

class StateSubject {
  private observers: StateObserver[] = [];
  private state = 0;

  attach(observer: StateObserver): void {
    if (this.observers.includes(observer)) {
      console.log("Subject: Observer has been attached already.");
      return;
    }
    this.observers.push(observer);
    console.log("Subject: Attached an observer.");
  }

  detach(observer: StateObserver): void {
    const index = this.observers.indexOf(observer);
    if (index === -1) {
      console.log("Subject: Nonexistent observer.");
      return;
    }
    this.observers.splice(index, 1);
    console.log("Subject: Detached an observer.");
  }

  setState(state: number): void {
    this.state = state;
    console.log(`Subject: state changed to ${state}`);
    for (const observer of this.observers) {
      observer.update(this.state);
    }
  }
}

class ObserverA implements StateObserver {
  update(state: number): void {
    if (state < 3) console.log("ObserverA: reacted");
  }
}

class ObserverB implements StateObserver {
  update(state: number): void {
    if (state === 0 || state >= 2) console.log("ObserverB: reacted");
  }
}

const subject = new StateSubject();
const observerA = new ObserverA();
const observerB = new ObserverB();

subject.attach(observerA);
subject.attach(observerB);
subject.setState(2);
subject.setState(1);
subject.detach(observerA);
subject.setState(0);

Subject: Attached an observer.
Subject: Attached an observer.
Subject: state changed to 2
ObserverA: reacted
ObserverB: reacted
Subject: state changed to 1
ObserverA: reacted
Subject: Detached an observer.
Subject: state changed to 0
ObserverB: reacted

interface PaymentStrategy {
  pay(amount: number): void;
}

class CreditCardPayment implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`Paid ${amount} using Credit Card.`);
  }
}

class BankTransferPayment implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`Paid ${amount} using Bank Transfer.`);
  }
}

class ShoppingCart {
  private paymentStrategy?: PaymentStrategy;

  constructor(private amount: number) {}

  setPaymentStrategy(strategy: PaymentStrategy): void {
    this.paymentStrategy = strategy;
  }

  checkout(): void {
    if (this.paymentStrategy === undefined) {
      console.log("No payment strategy selected!");
      return;
    }
    this.paymentStrategy.pay(this.amount);
  }
}

const cart = new ShoppingCart(250);
cart.checkout();
cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout();
cart.setPaymentStrategy(new BankTransferPayment());
cart.checkout();

No payment strategy selected!
Paid 250 using Credit Card.
Paid 250 using Bank Transfer.