Kādus projektēšanas modeļus esat izmantojis praksē…

Praktiskajā darbā es izmantoju šādus projektēšanas modeļus:

Fabrikas metode (Factory Method): Objekti tiek izveidoti dažādu tipu bez konkrētas klases norādīšanas. Tas ir ērti, strādājot ar dažādiem datu avotiem vai konfigurācijām.

// Piemērs, kā izmantot fabrikas metodi
class DataReader {
  read() {
    throw new Error("Metode nav īstenota");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("Datu lasīšana no faila...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("Datu lasīšana no tīkla...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("Nezināms lasītāja tips");
    }
  }
}

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

Vienīgais (Singleton): Nodrošina, ka ir tikai viena klases instance un pieejama globāli. Bieži tiek izmantots konfigurācijas pārvaldniekiem vai datu bāzes savienojumiem.

// Piemērs, kā izmantot 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); // patiesi

Novērotājs (Observer): Realizēt "viens-uz-daudz" saiti, kur viena objekta (publicētāja) stāvokļa izmaiņās automātiski tiek informēti visi atkarīgie objekti (abonenti). Lieto paziņojumu sistēmās, reaktīvos interfeisos.

// Piemērs, kā izmantot novērotāju
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("Saņemts atjauninājums:", data);
  }
}

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

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

observable.notify("Jauni dati pieejami!");

Stratēģija (Strategy): Definēt algoritmu ģimeni, tos iepakot un ļaut klientiem tos mainīt. Algoritms var mainīties neatkarīgi no klientiem, kas to izmanto. Lieto datu apstrādei vai operāciju veikšanai.

// Piemērs, kā izmantot stratēģiju
class PaymentStrategy {
  pay(amount) {
    throw new Error("Metode nav īstenota");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Maksājot ${amount} ar kredītkarti`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Maksājot ${amount} ar 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);

Dekorators (Decorator): Dinamiski pievienot jaunu funkcionalitāti objektam, nemainot tā struktūru. Apvij objekta, nodrošinot to pašu interfeisu, bet ar papildus funkcionalitāti. Noder logēšanai, validācijai, kešatmiņai.

// Dekoratora piemērs
class Component {
  operation() {
    return "Pamata komponenta";
  }
}

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

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

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

class ConcreteDecoratorB extends Decorator {
  operation() {
    return `Konkretā dekoratorsB(${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): Lai gan Node.js modulārais sistēma (CommonJS, ES Modules) ir iebūvēta, JavaScript valodā Module pattern (vecāks veids) tika izmantots privātu locekļu un publiskās saskarnes izveidei. Tas ir inkapsulācijas pamats.

Šie modeļi palīdzēja man veidot strukturētāku, paplašināmāku un uzturamu kodu.

Kādus projektēšanas modeļus esat izmantojis praksē?