디자인 패턴 현대적 가이드 2025: TypeScript/Python/Go로 배우는 GoF 패턴 + 현대 패턴

GoF 23 패턴 분류

생성(Creational) 5개: 객체 생성 메커니즘
├── Factory Method
├── Abstract Factory
├── Builder
├── Singleton
└── Prototype

구조(Structural) 7개: 객체 합성/구조화
├── Adapter
├── Bridge
├── Composite
├── Decorator
├── Facade
├── Flyweight
└── Proxy

행위(Behavioral) 11개: 객체 간 상호작용
├── Chain of Responsibility
├── Command
├── Iterator
├── Mediator
├── Memento
├── Observer
├── State
├── Strategy
├── Template Method
├── Visitor
└── Interpreter

// Bad: 여러 책임이 혼재
class UserService {
  createUser(data: UserData): User { /* ... */ }
  sendWelcomeEmail(user: User): void { /* ... */ }
  generateReport(users: User[]): PDF { /* ... */ }
}

// Good: 책임 분리
class UserService {
  createUser(data: UserData): User { /* ... */ }
}

class EmailService {
  sendWelcomeEmail(user: User): void { /* ... */ }
}

class ReportService {
  generateReport(users: User[]): PDF { /* ... */ }
}

# Bad: 새 할인 유형마다 코드 수정 필요
def calculate_discount(order, discount_type):
    if discount_type == "percentage":
        return order.total * 0.1
    elif discount_type == "fixed":
        return 10.0
    # 새 할인 추가 시 여기를 수정해야 함

# Good: 새 할인 유형을 추가만 하면 됨
from abc import ABC, abstractmethod

class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, order) -> float:
        pass

class PercentageDiscount(DiscountStrategy):
    def __init__(self, rate: float):
        self.rate = rate

    def calculate(self, order) -> float:
        return order.total * self.rate

class FixedDiscount(DiscountStrategy):
    def __init__(self, amount: float):
        self.amount = amount

    def calculate(self, order) -> float:
        return self.amount

// Bad: 거대한 인터페이스
type Worker interface {
    Work()
    Eat()
    Sleep()
}

// Good: 분리된 인터페이스
type Workable interface {
    Work()
}

type Eatable interface {
    Eat()
}

// Go는 인터페이스 합성이 자연스럽다
type HumanWorker interface {
    Workable
    Eatable
}

// TypeScript Factory Method
interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string): void {
    console.log(`[Console] ${message}`);
  }
}

class FileLogger implements Logger {
  log(message: string): void {
    // 파일에 기록
    console.log(`[File] ${message}`);
  }
}

class CloudLogger implements Logger {
  log(message: string): void {
    // 클라우드 서비스로 전송
    console.log(`[Cloud] ${message}`);
  }
}

// Factory
type LoggerType = "console" | "file" | "cloud";

function createLogger(type: LoggerType): Logger {
  const loggers: Record<LoggerType, () => Logger> = {
    console: () => new ConsoleLogger(),
    file: () => new FileLogger(),
    cloud: () => new CloudLogger(),
  };

  const factory = loggers[type];
  if (!factory) {
    throw new Error(`Unknown logger type: ${type}`);
  }
  return factory();
}

// 사용
const logger = createLogger("cloud");
logger.log("Application started");

# Python Factory Method
from abc import ABC, abstractmethod
from enum import Enum

class NotificationType(Enum):
    EMAIL = "email"
    SMS = "sms"
    PUSH = "push"
    SLACK = "slack"

class Notification(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str) -> bool:
        pass

class EmailNotification(Notification):
    def send(self, recipient: str, message: str) -> bool:
        print(f"Sending email to {recipient}: {message}")
        return True

class SMSNotification(Notification):
    def send(self, recipient: str, message: str) -> bool:
        print(f"Sending SMS to {recipient}: {message}")
        return True

class PushNotification(Notification):
    def send(self, recipient: str, message: str) -> bool:
        print(f"Sending push to {recipient}: {message}")
        return True

class SlackNotification(Notification):
    def send(self, recipient: str, message: str) -> bool:
        print(f"Sending Slack to {recipient}: {message}")
        return True

# Factory with registry pattern
class NotificationFactory:
    _registry: dict[NotificationType, type[Notification]] = {
        NotificationType.EMAIL: EmailNotification,
        NotificationType.SMS: SMSNotification,
        NotificationType.PUSH: PushNotification,
        NotificationType.SLACK: SlackNotification,
    }

    @classmethod
    def register(cls, ntype: NotificationType, klass: type[Notification]):
        cls._registry[ntype] = klass

    @classmethod
    def create(cls, ntype: NotificationType) -> Notification:
        klass = cls._registry.get(ntype)
        if not klass:
            raise ValueError(f"Unknown notification type: {ntype}")
        return klass()

# 사용
notifier = NotificationFactory.create(NotificationType.SLACK)
notifier.send("team-channel", "Deploy complete!")

// TypeScript Abstract Factory — UI 테마 시스템
interface Button {
  render(): string;
}

interface Input {
  render(): string;
}

interface Modal {
  render(): string;
}

// Abstract Factory
interface UIFactory {
  createButton(label: string): Button;
  createInput(placeholder: string): Input;
  createModal(title: string): Modal;
}

// Light Theme 구현
class LightButton implements Button {
  constructor(private label: string) {}
  render() { return `<button class="bg-white text-black">${this.label}</button>`; }
}

class LightInput implements Input {
  constructor(private placeholder: string) {}
  render() { return `<input class="border-gray-300" placeholder="${this.placeholder}" />`; }
}

class LightModal implements Modal {
  constructor(private title: string) {}
  render() { return `<div class="bg-white shadow-lg">${this.title}</div>`; }
}

class LightThemeFactory implements UIFactory {
  createButton(label: string) { return new LightButton(label); }
  createInput(placeholder: string) { return new LightInput(placeholder); }
  createModal(title: string) { return new LightModal(title); }
}

// Dark Theme 구현
class DarkButton implements Button {
  constructor(private label: string) {}
  render() { return `<button class="bg-gray-800 text-white">${this.label}</button>`; }
}

class DarkInput implements Input {
  constructor(private placeholder: string) {}
  render() { return `<input class="border-gray-600 bg-gray-700" placeholder="${this.placeholder}" />`; }
}

class DarkModal implements Modal {
  constructor(private title: string) {}
  render() { return `<div class="bg-gray-900 text-white">${this.title}</div>`; }
}

class DarkThemeFactory implements UIFactory {
  createButton(label: string) { return new DarkButton(label); }
  createInput(placeholder: string) { return new DarkInput(placeholder); }
  createModal(title: string) { return new DarkModal(title); }
}

// 사용 — 테마 전환이 한 줄로
function buildUI(factory: UIFactory) {
  const btn = factory.createButton("Submit");
  const input = factory.createInput("Enter name...");
  const modal = factory.createModal("Settings");
  return { btn, input, modal };
}

const ui = buildUI(new DarkThemeFactory());

// TypeScript Builder
interface HttpRequest {
  method: string;
  url: string;
  headers: Record<string, string>;
  body?: string;
  timeout: number;
  retries: number;
}

class HttpRequestBuilder {
  private request: Partial<HttpRequest> = {
    method: "GET",
    headers: {},
    timeout: 30000,
    retries: 0,
  };

  setMethod(method: string): this {
    this.request.method = method;
    return this;
  }

  setUrl(url: string): this {
    this.request.url = url;
    return this;
  }

  addHeader(key: string, value: string): this {
    this.request.headers![key] = value;
    return this;
  }

  setBody(body: string): this {
    this.request.body = body;
    return this;
  }

  setTimeout(ms: number): this {
    this.request.timeout = ms;
    return this;
  }

  setRetries(count: number): this {
    this.request.retries = count;
    return this;
  }

  build(): HttpRequest {
    if (!this.request.url) {
      throw new Error("URL is required");
    }
    return this.request as HttpRequest;
  }
}

// 사용: 가독성이 뛰어남
const request = new HttpRequestBuilder()
  .setMethod("POST")
  .setUrl("https://api.example.com/users")
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer token123")
  .setBody(JSON.stringify({ name: "John" }))
  .setTimeout(5000)
  .setRetries(3)
  .build();

# Python Builder — dataclass + builder
from dataclasses import dataclass, field
from typing import Optional

@dataclass(frozen=True)
class QueryConfig:
    table: str
    columns: list[str] = field(default_factory=lambda: ["*"])
    conditions: list[str] = field(default_factory=list)
    order_by: Optional[str] = None
    limit: Optional[int] = None
    offset: int = 0

class QueryBuilder:
    def __init__(self, table: str):
        self._table = table
        self._columns: list[str] = ["*"]
        self._conditions: list[str] = []
        self._order_by: Optional[str] = None
        self._limit: Optional[int] = None
        self._offset: int = 0

    def select(self, *columns: str) -> "QueryBuilder":
        self._columns = list(columns)
        return self

    def where(self, condition: str) -> "QueryBuilder":
        self._conditions.append(condition)
        return self

    def order_by(self, column: str, desc: bool = False) -> "QueryBuilder":
        direction = "DESC" if desc else "ASC"
        self._order_by = f"{column} {direction}"
        return self

    def limit(self, n: int) -> "QueryBuilder":
        self._limit = n
        return self

    def offset(self, n: int) -> "QueryBuilder":
        self._offset = n
        return self

    def build(self) -> QueryConfig:
        return QueryConfig(
            table=self._table,
            columns=self._columns,
            conditions=self._conditions,
            order_by=self._order_by,
            limit=self._limit,
            offset=self._offset,
        )

    def to_sql(self) -> str:
        cols = ", ".join(self._columns)
        sql = f"SELECT {cols} FROM {self._table}"
        if self._conditions:
            sql += " WHERE " + " AND ".join(self._conditions)
        if self._order_by:
            sql += f" ORDER BY {self._order_by}"
        if self._limit:
            sql += f" LIMIT {self._limit}"
        if self._offset:
            sql += f" OFFSET {self._offset}"
        return sql

# 사용
query = (
    QueryBuilder("users")
    .select("id", "name", "email")
    .where("status = 'active'")
    .where("age > 18")
    .order_by("created_at", desc=True)
    .limit(20)
    .offset(40)
)
print(query.to_sql())
# SELECT id, name, email FROM users WHERE status = 'active' AND age > 18 ORDER BY created_at DESC LIMIT 20 OFFSET 40

// TypeScript Singleton — 현대적 접근
class ConfigManager {
  private static instance: ConfigManager | null = null;
  private config: Map<string, unknown> = new Map();

  private constructor() {
    // private 생성자 — 외부에서 new 불가
  }

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

  get<T>(key: string): T | undefined {
    return this.config.get(key) as T | undefined;
  }

  set(key: string, value: unknown): void {
    this.config.set(key, value);
  }
}

// 사용
const config = ConfigManager.getInstance();
config.set("database.host", "localhost");

// Go Singleton — sync.Once 활용
package config

import "sync"

type AppConfig struct {
    DatabaseURL string
    RedisURL    string
    Port        int
}

var (
    instance *AppConfig
    once     sync.Once
)

func GetConfig() *AppConfig {
    once.Do(func() {
        instance = &AppConfig{
            DatabaseURL: "postgres://localhost:5432/app",
            RedisURL:    "redis://localhost:6379",
            Port:        8080,
        }
    })
    return instance
}

// TypeScript Prototype
interface Cloneable<T> {
  clone(): T;
}

class GameCharacter implements Cloneable<GameCharacter> {
  constructor(
    public name: string,
    public health: number,
    public attack: number,
    public defense: number,
    public skills: string[],
    public inventory: Map<string, number>,
  ) {}

  clone(): GameCharacter {
    return new GameCharacter(
      this.name,
      this.health,
      this.attack,
      this.defense,
      [...this.skills],
      new Map(this.inventory),
    );
  }
}

// 프로토타입 레지스트리
const archetypes = {
  warrior: new GameCharacter("Warrior", 200, 30, 50, ["Slash", "Shield"], new Map([["potion", 3]])),
  mage: new GameCharacter("Mage", 100, 60, 20, ["Fireball", "Heal"], new Map([["mana_potion", 5]])),
};

// 복제하여 커스터마이즈
const myWarrior = archetypes.warrior.clone();
myWarrior.name = "Aragorn";
myWarrior.skills.push("Charge");

// TypeScript Adapter — 외부 결제 라이브러리 통합
// 우리 시스템의 결제 인터페이스
interface PaymentProcessor {
  charge(amount: number, currency: string): Promise<PaymentResult>;
  refund(transactionId: string, amount: number): Promise<RefundResult>;
}

interface PaymentResult {
  success: boolean;
  transactionId: string;
}

interface RefundResult {
  success: boolean;
  refundId: string;
}

// 외부 라이브러리 (변경 불가)
class StripeSDK {
  async createCharge(params: {
    amount_cents: number;
    currency: string;
  }): Promise<{ id: string; status: string }> {
    // Stripe API 호출
    return { id: "ch_123", status: "succeeded" };
  }

  async createRefund(params: {
    charge: string;
    amount_cents: number;
  }): Promise<{ id: string; status: string }> {
    return { id: "re_456", status: "succeeded" };
  }
}

// Adapter
class StripeAdapter implements PaymentProcessor {
  private stripe: StripeSDK;

  constructor() {
    this.stripe = new StripeSDK();
  }

  async charge(amount: number, currency: string): Promise<PaymentResult> {
    const result = await this.stripe.createCharge({
      amount_cents: Math.round(amount * 100),
      currency: currency.toLowerCase(),
    });
    return {
      success: result.status === "succeeded",
      transactionId: result.id,
    };
  }

  async refund(transactionId: string, amount: number): Promise<RefundResult> {
    const result = await this.stripe.createRefund({
      charge: transactionId,
      amount_cents: Math.round(amount * 100),
    });
    return {
      success: result.status === "succeeded",
      refundId: result.id,
    };
  }
}

// 사용 — 우리 코드는 PaymentProcessor만 알면 됨
const processor: PaymentProcessor = new StripeAdapter();
const result = await processor.charge(29.99, "USD");

# Python Decorator — 로깅, 캐싱, 재시도를 조합
import functools
import time
import logging
from typing import Callable, TypeVar, ParamSpec

P = ParamSpec("P")
R = TypeVar("R")

def with_logging(func: Callable[P, R]) -> Callable[P, R]:
    """함수 호출을 로깅"""
    @functools.wraps(func)
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
        logging.info(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        logging.info(f"{func.__name__} returned in {elapsed:.3f}s")
        return result
    return wrapper

def with_retry(max_retries: int = 3, delay: float = 1.0):
    """실패 시 재시도"""
    def decorator(func: Callable[P, R]) -> Callable[P, R]:
        @functools.wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            last_error: Exception | None = None
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    logging.warning(
                        f"Attempt {attempt + 1}/{max_retries} failed: {e}"
                    )
                    if attempt < max_retries - 1:
                        time.sleep(delay * (2 ** attempt))
            raise last_error  # type: ignore
        return wrapper
    return decorator

def with_cache(ttl_seconds: int = 300):
    """결과 캐싱"""
    cache: dict[str, tuple[float, object]] = {}

    def decorator(func: Callable[P, R]) -> Callable[P, R]:
        @functools.wraps(func)
        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
            key = f"{args}-{kwargs}"
            if key in cache:
                cached_time, cached_value = cache[key]
                if time.time() - cached_time < ttl_seconds:
                    return cached_value  # type: ignore
            result = func(*args, **kwargs)
            cache[key] = (time.time(), result)
            return result
        return wrapper
    return decorator

# 데코레이터 조합 — 바깥에서 안쪽 순서로 적용
@with_logging
@with_retry(max_retries=3, delay=0.5)
@with_cache(ttl_seconds=60)
def fetch_user_profile(user_id: int) -> dict:
    """외부 API에서 사용자 프로필 조회"""
    import requests
    response = requests.get(f"https://api.example.com/users/{user_id}")
    response.raise_for_status()
    return response.json()

// TypeScript Facade — 주문 처리 시스템
class InventoryService {
  checkStock(productId: string): boolean {
    // 재고 확인 로직
    return true;
  }
  reserveStock(productId: string, qty: number): void { /* ... */ }
}

class PaymentService {
  processPayment(userId: string, amount: number): string {
    // 결제 처리
    return "txn_789";
  }
  refundPayment(txnId: string): void { /* ... */ }
}

class ShippingService {
  calculateShipping(address: string): number { return 5.99; }
  createShipment(orderId: string, address: string): string {
    return "ship_101";
  }
}

class NotificationService {
  sendOrderConfirmation(email: string, orderId: string): void { /* ... */ }
  sendShippingNotification(email: string, trackingId: string): void { /* ... */ }
}

// Facade — 복잡한 프로세스를 단순한 메서드로
class OrderFacade {
  private inventory = new InventoryService();
  private payment = new PaymentService();
  private shipping = new ShippingService();
  private notification = new NotificationService();

  async placeOrder(order: {
    userId: string;
    email: string;
    productId: string;
    quantity: number;
    address: string;
    amount: number;
  }): Promise<{ orderId: string; trackingId: string }> {
    // 1. 재고 확인
    if (!this.inventory.checkStock(order.productId)) {
      throw new Error("Out of stock");
    }

    // 2. 재고 예약
    this.inventory.reserveStock(order.productId, order.quantity);

    // 3. 결제 처리
    const shippingCost = this.shipping.calculateShipping(order.address);
    const txnId = this.payment.processPayment(
      order.userId,
      order.amount + shippingCost,
    );

    // 4. 배송 생성
    const orderId = `ORD-${Date.now()}`;
    const trackingId = this.shipping.createShipment(orderId, order.address);

    // 5. 알림 발송
    this.notification.sendOrderConfirmation(order.email, orderId);

    return { orderId, trackingId };
  }
}

// 사용 — 클라이언트는 Facade만 알면 됨
const orderService = new OrderFacade();
const result = await orderService.placeOrder({
  userId: "user_1",
  email: "user@example.com",
  productId: "prod_42",
  quantity: 1,
  address: "Seoul, Korea",
  amount: 49.99,
});

// TypeScript Proxy — 지연 로딩 + 접근 제어
interface Database {
  query(sql: string): Promise<unknown[]>;
  execute(sql: string): Promise<void>;
}

class PostgresDatabase implements Database {
  private pool: unknown; // 실제 DB 풀

  constructor(connectionString: string) {
    console.log("Establishing DB connection pool...");
    // 비용이 큰 초기화
    this.pool = {}; // 실제로는 connection pool 생성
  }

  async query(sql: string): Promise<unknown[]> {
    console.log(`Executing query: ${sql}`);
    return [];
  }

  async execute(sql: string): Promise<void> {
    console.log(`Executing: ${sql}`);
  }
}

class DatabaseProxy implements Database {
  private db: PostgresDatabase | null = null;
  private connectionString: string;
  private userRole: string;

  constructor(connectionString: string, userRole: string) {
    this.connectionString = connectionString;
    this.userRole = userRole;
    // DB 연결을 아직 하지 않음 — 지연 로딩
  }

  private getDb(): PostgresDatabase {
    if (!this.db) {
      this.db = new PostgresDatabase(this.connectionString);
    }
    return this.db;
  }

  async query(sql: string): Promise<unknown[]> {
    console.log(`[Proxy] Query requested by role: ${this.userRole}`);
    return this.getDb().query(sql);
  }

  async execute(sql: string): Promise<void> {
    if (this.userRole !== "admin") {
      throw new Error("Only admin can execute write operations");
    }
    console.log(`[Proxy] Execute requested by role: ${this.userRole}`);
    return this.getDb().execute(sql);
  }
}

# Python Composite — 파일 시스템
from abc import ABC, abstractmethod

class FileSystemItem(ABC):
    def __init__(self, name: str):
        self.name = name

    @abstractmethod
    def get_size(self) -> int:
        pass

    @abstractmethod
    def display(self, indent: int = 0) -> str:
        pass

class File(FileSystemItem):
    def __init__(self, name: str, size: int):
        super().__init__(name)
        self.size = size

    def get_size(self) -> int:
        return self.size

    def display(self, indent: int = 0) -> str:
        return " " * indent + f"File: {self.name} ({self.size} bytes)"

class Directory(FileSystemItem):
    def __init__(self, name: str):
        super().__init__(name)
        self.children: list[FileSystemItem] = []

    def add(self, item: FileSystemItem) -> "Directory":
        self.children.append(item)
        return self

    def get_size(self) -> int:
        return sum(child.get_size() for child in self.children)

    def display(self, indent: int = 0) -> str:
        lines = [" " * indent + f"Dir: {self.name} ({self.get_size()} bytes)"]
        for child in self.children:
            lines.append(child.display(indent + 2))
        return "\n".join(lines)

# 사용
root = Directory("project")
src = Directory("src")
src.add(File("main.ts", 2048))
src.add(File("utils.ts", 1024))
root.add(src)
root.add(File("package.json", 512))
root.add(File("README.md", 256))

print(root.display())
print(f"Total size: {root.get_size()} bytes")

// TypeScript Strategy — 가격 계산 전략
interface PricingStrategy {
  calculatePrice(basePrice: number, quantity: number): number;
  getName(): string;
}

class RegularPricing implements PricingStrategy {
  calculatePrice(basePrice: number, quantity: number): number {
    return basePrice * quantity;
  }
  getName() { return "Regular"; }
}

class BulkPricing implements PricingStrategy {
  calculatePrice(basePrice: number, quantity: number): number {
    if (quantity >= 100) return basePrice * quantity * 0.7;
    if (quantity >= 50) return basePrice * quantity * 0.8;
    if (quantity >= 10) return basePrice * quantity * 0.9;
    return basePrice * quantity;
  }
  getName() { return "Bulk"; }
}

class SubscriptionPricing implements PricingStrategy {
  constructor(private discountRate: number) {}
  calculatePrice(basePrice: number, quantity: number): number {
    return basePrice * quantity * (1 - this.discountRate);
  }
  getName() { return "Subscription"; }
}

class SeasonalPricing implements PricingStrategy {
  constructor(private seasonMultiplier: number) {}
  calculatePrice(basePrice: number, quantity: number): number {
    return basePrice * quantity * this.seasonMultiplier;
  }
  getName() { return "Seasonal"; }
}

// Context
class ShoppingCart {
  private items: Array<{ name: string; price: number; quantity: number }> = [];
  private strategy: PricingStrategy = new RegularPricing();

  setPricingStrategy(strategy: PricingStrategy): void {
    this.strategy = strategy;
    console.log(`Pricing strategy set to: ${strategy.getName()}`);
  }

  addItem(name: string, price: number, quantity: number): void {
    this.items.push({ name, price, quantity });
  }

  calculateTotal(): number {
    return this.items.reduce(
      (total, item) => total + this.strategy.calculatePrice(item.price, item.quantity),
      0,
    );
  }
}

// 사용
const cart = new ShoppingCart();
cart.addItem("Widget", 10, 100);

cart.setPricingStrategy(new RegularPricing());
console.log(`Regular: $${cart.calculateTotal()}`); // 1000

cart.setPricingStrategy(new BulkPricing());
console.log(`Bulk: $${cart.calculateTotal()}`); // 700

cart.setPricingStrategy(new SubscriptionPricing(0.15));
console.log(`Subscription: $${cart.calculateTotal()}`); // 850

// TypeScript Observer — 타입 안전한 이벤트 시스템
type EventMap = {
  "user:created": { userId: string; email: string };
  "user:updated": { userId: string; changes: Record<string, unknown> };
  "order:placed": { orderId: string; userId: string; total: number };
  "order:shipped": { orderId: string; trackingNumber: string };
};

type EventHandler<T> = (data: T) => void | Promise<void>;

class EventEmitter {
  private handlers = new Map<string, Set<EventHandler<any>>>();

  on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): () => void {
    if (!this.handlers.has(event)) {
      this.handlers.set(event, new Set());
    }
    this.handlers.get(event)!.add(handler);

    // unsubscribe 함수 반환
    return () => {
      this.handlers.get(event)?.delete(handler);
    };
  }

  async emit<K extends keyof EventMap>(event: K, data: EventMap[K]): Promise<void> {
    const eventHandlers = this.handlers.get(event);
    if (!eventHandlers) return;

    const promises = Array.from(eventHandlers).map((handler) =>
      Promise.resolve(handler(data))
    );
    await Promise.allSettled(promises);
  }
}

// 사용
const events = new EventEmitter();

// 구독자 등록
events.on("user:created", async (data) => {
  console.log(`Send welcome email to ${data.email}`);
});

events.on("user:created", async (data) => {
  console.log(`Initialize user preferences for ${data.userId}`);
});

events.on("order:placed", async (data) => {
  console.log(`Process payment for order ${data.orderId}: $${data.total}`);
});

// 이벤트 발행
await events.emit("user:created", { userId: "u_1", email: "user@example.com" });
await events.emit("order:placed", { orderId: "ord_1", userId: "u_1", total: 99.99 });

# Python Command — Undo/Redo 지원 텍스트 에디터
from abc import ABC, abstractmethod
from dataclasses import dataclass, field

class Command(ABC):
    @abstractmethod
    def execute(self) -> None:
        pass

    @abstractmethod
    def undo(self) -> None:
        pass

    @abstractmethod
    def describe(self) -> str:
        pass

class TextEditor:
    def __init__(self):
        self.content: list[str] = []
        self._cursor: int = 0

    @property
    def text(self) -> str:
        return "".join(self.content)

    def insert_at(self, position: int, text: str) -> None:
        for i, char in enumerate(text):
            self.content.insert(position + i, char)

    def delete_range(self, start: int, length: int) -> str:
        deleted = self.content[start:start + length]
        del self.content[start:start + length]
        return "".join(deleted)

class InsertCommand(Command):
    def __init__(self, editor: TextEditor, position: int, text: str):
        self.editor = editor
        self.position = position
        self.text = text

    def execute(self) -> None:
        self.editor.insert_at(self.position, self.text)

    def undo(self) -> None:
        self.editor.delete_range(self.position, len(self.text))

    def describe(self) -> str:
        return f"Insert '{self.text}' at position {self.position}"

class DeleteCommand(Command):
    def __init__(self, editor: TextEditor, position: int, length: int):
        self.editor = editor
        self.position = position
        self.length = length
        self.deleted_text: str = ""

    def execute(self) -> None:
        self.deleted_text = self.editor.delete_range(self.position, self.length)

    def undo(self) -> None:
        self.editor.insert_at(self.position, self.deleted_text)

    def describe(self) -> str:
        return f"Delete {self.length} chars at position {self.position}"

@dataclass
class CommandHistory:
    undo_stack: list[Command] = field(default_factory=list)
    redo_stack: list[Command] = field(default_factory=list)

    def execute(self, command: Command) -> None:
        command.execute()
        self.undo_stack.append(command)
        self.redo_stack.clear()

    def undo(self) -> str | None:
        if not self.undo_stack:
            return None
        command = self.undo_stack.pop()
        command.undo()
        self.redo_stack.append(command)
        return command.describe()

    def redo(self) -> str | None:
        if not self.redo_stack:
            return None
        command = self.redo_stack.pop()
        command.execute()
        self.undo_stack.append(command)
        return command.describe()

# 사용
editor = TextEditor()
history = CommandHistory()

history.execute(InsertCommand(editor, 0, "Hello World"))
print(editor.text)  # "Hello World"

history.execute(InsertCommand(editor, 5, ","))
print(editor.text)  # "Hello, World"

history.undo()
print(editor.text)  # "Hello World"

history.redo()
print(editor.text)  # "Hello, World"

// TypeScript State — 주문 상태 머신
interface OrderState {
  name: string;
  confirm(order: Order): void;
  ship(order: Order): void;
  deliver(order: Order): void;
  cancel(order: Order): void;
}

class PendingState implements OrderState {
  name = "Pending";
  confirm(order: Order) { order.setState(new ConfirmedState()); }
  ship(_order: Order) { throw new Error("Cannot ship a pending order"); }
  deliver(_order: Order) { throw new Error("Cannot deliver a pending order"); }
  cancel(order: Order) { order.setState(new CancelledState()); }
}

class ConfirmedState implements OrderState {
  name = "Confirmed";
  confirm(_order: Order) { throw new Error("Order already confirmed"); }
  ship(order: Order) { order.setState(new ShippedState()); }
  deliver(_order: Order) { throw new Error("Cannot deliver before shipping"); }
  cancel(order: Order) { order.setState(new CancelledState()); }
}

class ShippedState implements OrderState {
  name = "Shipped";
  confirm(_order: Order) { throw new Error("Order already shipped"); }
  ship(_order: Order) { throw new Error("Order already shipped"); }
  deliver(order: Order) { order.setState(new DeliveredState()); }
  cancel(_order: Order) { throw new Error("Cannot cancel a shipped order"); }
}

class DeliveredState implements OrderState {
  name = "Delivered";
  confirm() { throw new Error("Order already delivered"); }
  ship() { throw new Error("Order already delivered"); }
  deliver() { throw new Error("Order already delivered"); }
  cancel() { throw new Error("Cannot cancel a delivered order"); }
}

class CancelledState implements OrderState {
  name = "Cancelled";
  confirm() { throw new Error("Order is cancelled"); }
  ship() { throw new Error("Order is cancelled"); }
  deliver() { throw new Error("Order is cancelled"); }
  cancel() { throw new Error("Order already cancelled"); }
}

class Order {
  private state: OrderState = new PendingState();

  setState(state: OrderState): void {
    console.log(`Order state: ${this.state.name} -> ${state.name}`);
    this.state = state;
  }

  getState(): string { return this.state.name; }
  confirm() { this.state.confirm(this); }
  ship() { this.state.ship(this); }
  deliver() { this.state.deliver(this); }
  cancel() { this.state.cancel(this); }
}

// 사용
const order = new Order();
order.confirm();   // Pending -> Confirmed
order.ship();      // Confirmed -> Shipped
order.deliver();   // Shipped -> Delivered

# Python Template Method — 데이터 처리 파이프라인
from abc import ABC, abstractmethod
from typing import Any
import json
import csv
from io import StringIO

class DataProcessor(ABC):
    """데이터 처리 파이프라인 — 템플릿 메서드"""

    def process(self, source: str) -> dict[str, Any]:
        """템플릿 메서드: 처리 흐름을 정의"""
        raw_data = self.extract(source)
        validated = self.validate(raw_data)
        transformed = self.transform(validated)
        result = self.load(transformed)
        self.notify(result)
        return result

    @abstractmethod
    def extract(self, source: str) -> list[dict]:
        """데이터 추출 — 하위 클래스가 구현"""
        pass

    def validate(self, data: list[dict]) -> list[dict]:
        """기본 검증 — 필요 시 오버라이드"""
        return [row for row in data if row]

    @abstractmethod
    def transform(self, data: list[dict]) -> list[dict]:
        """데이터 변환 — 하위 클래스가 구현"""
        pass

    def load(self, data: list[dict]) -> dict[str, Any]:
        """결과 반환 — 기본 구현"""
        return {"records": len(data), "data": data}

    def notify(self, result: dict[str, Any]) -> None:
        """처리 완료 알림 — 선택적 오버라이드"""
        print(f"Processed {result['records']} records")

class JSONProcessor(DataProcessor):
    def extract(self, source: str) -> list[dict]:
        return json.loads(source)

    def transform(self, data: list[dict]) -> list[dict]:
        return [{k.lower(): v for k, v in row.items()} for row in data]

class CSVProcessor(DataProcessor):
    def extract(self, source: str) -> list[dict]:
        reader = csv.DictReader(StringIO(source))
        return list(reader)

    def transform(self, data: list[dict]) -> list[dict]:
        for row in data:
            for key, value in row.items():
                try:
                    row[key] = float(value)
                except (ValueError, TypeError):
                    pass
        return data

// TypeScript Repository
interface Repository<T, ID> {
  findById(id: ID): Promise<T | null>;
  findAll(filter?: Partial<T>): Promise<T[]>;
  create(entity: Omit<T, "id">): Promise<T>;
  update(id: ID, data: Partial<T>): Promise<T>;
  delete(id: ID): Promise<boolean>;
}

interface User {
  id: string;
  name: string;
  email: string;
  role: string;
  createdAt: Date;
}

// 구현 — PostgreSQL
class PostgresUserRepository implements Repository<User, string> {
  constructor(private pool: any) {} // pg.Pool

  async findById(id: string): Promise<User | null> {
    const result = await this.pool.query(
      "SELECT * FROM users WHERE id = $1", [id]
    );
    return result.rows[0] || null;
  }

  async findAll(filter?: Partial<User>): Promise<User[]> {
    let query = "SELECT * FROM users";
    const conditions: string[] = [];
    const params: unknown[] = [];

    if (filter?.role) {
      conditions.push(`role = $${params.length + 1}`);
      params.push(filter.role);
    }
    if (filter?.email) {
      conditions.push(`email = $${params.length + 1}`);
      params.push(filter.email);
    }

    if (conditions.length > 0) {
      query += " WHERE " + conditions.join(" AND ");
    }

    const result = await this.pool.query(query, params);
    return result.rows;
  }

  async create(data: Omit<User, "id">): Promise<User> {
    const result = await this.pool.query(
      "INSERT INTO users (name, email, role, created_at) VALUES ($1, $2, $3, $4) RETURNING *",
      [data.name, data.email, data.role, data.createdAt]
    );
    return result.rows[0];
  }

  async update(id: string, data: Partial<User>): Promise<User> {
    const sets: string[] = [];
    const params: unknown[] = [];

    Object.entries(data).forEach(([key, value]) => {
      if (key !== "id" && value !== undefined) {
        sets.push(`${key} = $${params.length + 1}`);
        params.push(value);
      }
    });

    params.push(id);
    const result = await this.pool.query(
      `UPDATE users SET ${sets.join(", ")} WHERE id = $${params.length} RETURNING *`,
      params
    );
    return result.rows[0];
  }

  async delete(id: string): Promise<boolean> {
    const result = await this.pool.query(
      "DELETE FROM users WHERE id = $1", [id]
    );
    return result.rowCount > 0;
  }
}

// In-Memory 구현 — 테스트용
class InMemoryUserRepository implements Repository<User, string> {
  private users = new Map<string, User>();

  async findById(id: string): Promise<User | null> {
    return this.users.get(id) || null;
  }

  async findAll(filter?: Partial<User>): Promise<User[]> {
    let results = Array.from(this.users.values());
    if (filter?.role) results = results.filter((u) => u.role === filter.role);
    return results;
  }

  async create(data: Omit<User, "id">): Promise<User> {
    const user: User = { id: crypto.randomUUID(), ...data } as User;
    this.users.set(user.id, user);
    return user;
  }

  async update(id: string, data: Partial<User>): Promise<User> {
    const user = this.users.get(id);
    if (!user) throw new Error("User not found");
    const updated = { ...user, ...data };
    this.users.set(id, updated);
    return updated;
  }

  async delete(id: string): Promise<boolean> {
    return this.users.delete(id);
  }
}

// TypeScript CQRS
// Command — 쓰기
interface Command {
  type: string;
}

interface CreateOrderCommand extends Command {
  type: "CreateOrder";
  userId: string;
  items: Array<{ productId: string; quantity: number; price: number }>;
}

interface CancelOrderCommand extends Command {
  type: "CancelOrder";
  orderId: string;
  reason: string;
}

type OrderCommand = CreateOrderCommand | CancelOrderCommand;

// Command Handler
class OrderCommandHandler {
  async handle(command: OrderCommand): Promise<void> {
    switch (command.type) {
      case "CreateOrder":
        await this.createOrder(command);
        break;
      case "CancelOrder":
        await this.cancelOrder(command);
        break;
    }
  }

  private async createOrder(cmd: CreateOrderCommand): Promise<void> {
    // 비즈니스 로직 + 이벤트 발행
    const total = cmd.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
    console.log(`Order created for user ${cmd.userId}, total: ${total}`);
  }

  private async cancelOrder(cmd: CancelOrderCommand): Promise<void> {
    console.log(`Order ${cmd.orderId} cancelled: ${cmd.reason}`);
  }
}

// Query — 읽기 (최적화된 별도 모델)
interface OrderSummary {
  orderId: string;
  userName: string;
  totalAmount: number;
  status: string;
  itemCount: number;
}

class OrderQueryService {
  async getOrderSummary(orderId: string): Promise<OrderSummary | null> {
    // 읽기에 최적화된 뷰/테이블에서 조회
    return null;
  }

  async getUserOrders(userId: string): Promise<OrderSummary[]> {
    return [];
  }

  async getOrdersByStatus(status: string): Promise<OrderSummary[]> {
    return [];
  }
}