Milliseid disainimustreid olete praktikas jooksul…

Praktikas töö käigus kasutasin järgmisi disainimustreid:

Faktori meetod (Factory Method): Objektide loomine erinevat tüüpi ilma konkreetse klassi määramiseta. Sobib erinevate andmeallikate või konfiguratsioonidega töötamiseks.

// Näide faktori meetodi kasutamisest
class DataReader {
  read() {
    throw new Error("Meetodit ei ole rakendatud");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("Andmete lugemine failist...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("Andmete lugemine võrgust...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("Tundmatu lugeja tüüp");
    }
  }
}

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

Singleton (ühekordne): Tagab, et klassil on ainult üks eksemplar ning sellele on globaalne juurdepääs. Kasutatakse sageli konfiguratsiooni haldurite või andmebaasi ühenduste jaoks.

// Näide singletoni kasutamisest
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); // tõsi

Jälgija (Observer): Rakendada "üks-mitmele" seos, kus ühe objekti (väljastaja) oleku muutmisel teavitatakse automaatselt kõiki sõltuvaid objekte (tellijaid). Kasutatakse teavitussüsteemides, reaktiivsetes kasutajaliidestes.

// Näide jälgija kasutamisest
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("Vastuvõetud uuendus:", data);
  }
}

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

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

observable.notify("Uued andmed saadaval!");

Strateegia (Strategy): Määratleda algoritmide pere, neid kapseldada ja võimaldada nende vahetamist. Algoritm võib muutuda sõltumatult klientidest, kes seda kasutavad. Kasutatakse andmetöötluseks või operatsioonide teostamiseks.

// Näide strateegia kasutamisest
class PaymentStrategy {
  pay(amount) {
    throw new Error("Meetodit ei ole rakendatud");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Makse ${amount} krediitkaardiga`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`Makse ${amount} PayPaliga`);
  }
}

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

Dekoratiiv (Decorator): Dynaamiliselt lisada uue funktsionaalsuse objekti, muutmata selle struktuuri. Pakib olemasoleva objekti ja pakub sama liidest, kuid lisafunktsionaalsusega. Kasutatakse logimise, valideerimise, vahemälu jaoks.

// Dekoraatori näide
class Component {
  operation() {
    return "Põhikomponent";
  }
}

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

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

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

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

Moodul (Module): Kuigi Node.js-s on moodulite süsteem (CommonJS, ES Modules) sisseehitatud, JavaScriptis kasutati Module pattern (vana meetod) privaatsate liikmete ja avaliku liidese loomiseks. See on inkapsulatsiooni alus.

Need mustrid aitasid mul luua struktureeritumat, laiendatavamat ja hooldatavamat koodi.

Milliseid disainimustreid olete praktikas jooksul kasutanud?