Milyen tervezési mintákat használtál a gyakorlatban…

Gyakorlatban a következő tervezési mintákat alkalmaztam:

Gyártmódszer (Factory Method): Objektumok létrehozása különböző típusokhoz anélkül, hogy meg kellene határozni a konkrét osztályt. Hasznos különböző adatforrások vagy konfigurációk esetén.

// Példa a gyártmódszer használatára
class DataReader {
  read() {
    throw new Error("Nem implementált módszer");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("Adatok olvasása fájlból...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("Adatok olvasása hálózatról...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("Ismeretlen olvasó típus");
    }
  }
}

const factory = new DataReaderFactory();
const fileReader = factory.createReader("file");
fileReader.read();

Singleton (Egyszemélyes): Csak egy példány létezésének garantálása és globális hozzáférés biztosítása. Gyakran konfigurációs vagy adatbázis-kapcsolati menedzserekhez használják.

// Példa az egyszemélyes használatára
class ConfigManager {
  constructor() {
    if (ConfigManager.instance) {
      return ConfigManager.instance;
    }
    this.config = {};
    ConfigManager.instance = this;
  }

  setConfig(key, value) {
    this.config[key] = value;
  }

  getConfig(key) {
    return this.config[key];
  }
}

const instance1 = new ConfigManager();
const instance2 = new ConfigManager();

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

Megfigyelő (Observer): "Egy a sokhoz" kapcsolat megvalósítása, ahol egy objektum (kiadó) állapotának változásakor automatikusan értesülnek a függő objektumok (feliratkozók). Értesítési rendszerekben, reaktív felületeken használják.

// Példa megfigyelő használatára
class Observable {
  constructor() {
    this.observers = [];
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(obs => obs !== observer);
  }

  notify(data) {
    this.observers.forEach(observer => observer.update(data));
  }
}

class Observer {
  update(data) {
    console.log("Frissítés érkezett:", data);
  }
}

const observable = new Observable();
const observer1 = new Observer();
const observer2 = new Observer();

observable.subscribe(observer1);
observable.subscribe(observer2);

observable.notify("Új adat elérhető!");

Stratégia (Strategy): Algoritmuscsaládok meghatározása, azok inkapszulálása és cserélhetőségük biztosítása. Az algoritmus függetlenül változhat a kliensektől, akik használják. Különböző adatfeldolgozási vagy műveleti lehetőségekhez alkalmazható.

// Példa stratégia használatára
class PaymentStrategy {
  pay(amount) {
    throw new Error("Nem implementált módszer");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Fizetés ${amount} összeggel hitelkártyával`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Fizetés ${amount} összeggel PayPal-lal`);
  }
}

class PaymentContext {
  setStrategy(strategy) {
    this.strategy = strategy;
  }

  executePayment(amount) {
    this.strategy.pay(amount);
  }
}

const context = new PaymentContext();
context.setStrategy(new CreditCardPayment());
context.executePayment(100);

context.setStrategy(new PayPalPayment());
context.executePayment(50);

Dekorátor (Decorator): Dinamikusan új funkcionalitást ad hozzá egy objektumhoz anélkül, hogy megváltoztatná annak szerkezetét. A meglévő objektumot burkolja, ugyanazt az interfészt biztosítva, mint a burkolt objektum, de kiegészítve funkcionalitással. Hasznos naplózásra, validálásra, gyorsítótárazásra.

// Példa dekorátor használatára
class Component {
  operation() {
    return "Alap komponens";
  }
}

class Decorator {
  constructor(component) {
    this.component = component;
  }

  operation() {
    return this.component.operation();
  }
}

class ConcreteDecoratorA extends Decorator {
  operation() {
    return `ConcreteDecoratorA(${super.operation()})`;
  }
}

class ConcreteDecoratorB extends Decorator {
  operation() {
    return `ConcreteDecoratorB(${super.operation()})`;
  }
}

const simple = new Component();
console.log(simple.operation());

const decoratorA = new ConcreteDecoratorA(simple);
console.log(decoratorA.operation());

const decoratorB = new ConcreteDecoratorB(decoratorA);
console.log(decoratorB.operation());

Modul (Modul): Bár a Node.js beépített modulrendszert (CommonJS, ES Modules) használ, a JavaScript Module pattern (mielőtt a natív modulok megjelentek) a privát tagok és a nyilvános interfész létrehozására szolgált. Alapja a kód inkapszulálásának.

Ezek a minták segítettek abban, hogy strukturáltabb, skálázhatóbb és karbáthatóbb kódot írjak.

Milyen tervezési mintákat használtál a gyakorlatban?