Ce modele de proiectare ai folosit în practică…

În practică am aplicat următoarele modele de proiectare:

Metoda Fabrica (Factory Method): Pentru crearea de obiecte de diferite tipuri fără a specifica clasa concretă de creare. Este utilă atunci când se lucrează cu diferite surse de date sau configurații.

// Exemplu de utilizare a metodei fabrică
class DataReader {
  read() {
    throw new Error("Metoda neimplementată");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("Citire date din fișier...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("Citire date din rețea...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("Tip necunoscut de cititor");
    }
  }
}

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

Singleton (Singurul): Asigură existența unei singure instanțe a unei clase și oferă un punct global de acces la aceasta. Este folosit adesea pentru managerii de configurație sau conexiunile la baze de date.

// Exemplu de utilizare a singleton-ului
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

Observator (Observator): Pentru implementarea relației "unu-la-mulți", unde la schimbarea stării unui obiect (editor) sunt notificați automat toți obiectele dependente (abonamentele). Folosit în sisteme de notificare, interfețe reactive.

// Exemplu de utilizare a observatorului
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("Primite actualizare:", data);
  }
}

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

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

observable.notify("Date noi disponibile!");

Strategie (Strategy): Pentru definirea unei familii de algoritmi, încapsularea fiecăruia și asigurarea înlocuibilității lor. Permite schimbarea algoritmului independent de clienți. Se folosește pentru diferite variante de procesare a datelor sau executare a operațiilor.

// Exemplu de utilizare a strategiei
class PaymentStrategy {
  pay(amount) {
    throw new Error("Metoda neimplementată");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Plată de ${amount} folosind card de credit`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Plată de ${amount} prin 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);

Decoratoare (Decorator): Pentru adăugarea dinamică a noii funcționalități unui obiect fără a-i modifica structura. Înfășoară obiectul existent, oferind același interfaț ca și obiectul învelit, dar cu funcționalitate adăugată. Util pentru logare, validare, caching.

// Exemplu de utilizare a decoratorului
class Component {
  operation() {
    return "Component de bază";
  }
}

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): Deși sistemul de module în Node.js este încorporat (CommonJS, ES Modules), pattern-ul Module în JavaScript (până la apariția modulelor native) era folosit pentru crearea membrilor privați și a interfeței publice. Este fundamentul pentru construirea unui cod încapsulat.

Aceste modele m-au ajutat să creez un cod mai structurat, scalabil și ușor de întreținut.

Ce modele de proiectare ai folosit în practică?