Kokius projektavimo modelius naudojote praktikoje…

Praktikoje aš taikiau šiuos projektavimo modelius:

Fabriko metodas (Factory Method): Objektų kūrimas skirtingų tipų be konkretaus klasės nurodymo. Patogu dirbti su įvairiais duomenų šaltiniais ar konfigūracijomis.

// Pavyzdys, kaip naudoti fabrikos metodą
class DataReader {
  read() {
    throw new Error("Metodas nėra įgyvendintas");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("Skaitoma duomenys iš failo...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("Skaitoma duomenys iš tinklo...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("Nežinomas skaitytuvo tipas");
    }
  }
}

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

Singleton (vienkartinis): Užtikrinti, kad klasė turėtų tik vieną egzempliorių ir būtų prieinama globaliai. Dažnai naudojama konfigūracijos tvarkytuvams ar duomenų bazės jungtims.

// Pavyzdys, kaip naudoti singleton
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

Stebėtojas (Observer): Įgyvendinti "vienas-keli" ryšį, kai vieno objekto (skelbėjo) būsenos pasikeitimas automatiškai praneša visiems priklausomiems objektams (prenumeratoriams). Naudojama pranešimų sistemose, reaguojančiuose interfeisuose.

// Pavyzdys, kaip naudoti stebėtoją
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("Gauta naujinimas:", data);
  }
}

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

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

observable.notify("Nauji duomenys!");

Strategija (Strategy): Apibrėžti šeimą algoritmų, juos įpakuoti ir leisti keisti jų pasirinkimą. Algoritmas gali keistis nepriklausomai nuo klientų, kurie jį naudoja. Naudojama duomenų apdorojimui ar operacijų vykdymui.

// Pavyzdys, kaip naudoti strategiją
class PaymentStrategy {
  pay(amount) {
    throw new Error("Metodas nėra įgyvendintas");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Mokėjimas ${amount} naudojant kreditinę kortelę`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Mokėjimas ${amount} naudojant PayPal`);
  }
}

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);

Dekoratorius (Decorator): Dinamiškai pridėti naują funkcionalumą objektui, nekeičiant jo struktūros. Apvynioja esamą objektą, teikia tą patį sąsają, bet su papildoma funkcionalumu. Naudinga logavimui, validacijai, talpyklai.

// Pavyzdys, kaip naudoti dekoratorių
class Component {
  operation() {
    return "Pagrindinis komponentas";
  }
}

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

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

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

class ConcreteDecoratorB extends Decorator {
  operation() {
    return `KonkretusDekoratorB(${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());

Modulis (Module): Nors Node.js modulių sistema (CommonJS, ES Modules) yra įmontuota, JavaScript kalboje Module pattern (senas būdas) buvo naudojamas privačių narių ir viešojo sąsajos kūrimui. Tai yra inkapsuliacijos pagrindas.

Šie modeliai padėjo man kurti labiau struktūruotą, išplėstinę ir palaikomą kodą.

Kokius projektavimo modelius naudojote praktikoje?