რომელი დიზაინის ნიმუშები გამოიყენეთ პრაქტიკაში…

პრაქტიკაში მე გამოვიყენე შემდეგი დიზაინის ნიმუშები:

ფაბრიკის მეთოდი (Factory Method): ობიექტების შექმნა სხვადასხვა ტიპის, კონკრეტული კლასი მითითების გარეშე. მოსახერხებელია მონაცემთა წყაროებისა და კონფიგურაციების მუშაობისთვის.

// ფაბრიკის მეთოდის გამოყენების მაგალითი
class DataReader {
  read() {
    throw new Error("მეთოდი არ არის განხორციელებული");
  }
}

class FileReader extends DataReader {
  read() {
    console.log("მონაცემების კითხვა ფაილიდან...");
  }
}

class NetworkReader extends DataReader {
  read() {
    console.log("მონაცემების კითხვა ქსელიდან...");
  }
}

class DataReaderFactory {
  createReader(type) {
    switch (type) {
      case "file":
        return new FileReader();
      case "network":
        return new NetworkReader();
      default:
        throw new Error("უცნობი მკითხველი ტიპი");
    }
  }
}

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

სინგლტონი (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); // ჭეშმარიტი

დაკვირვებელი (Observer): რეალიზება "ერთი-მრავალი" კავშირის, სადაც ერთი ობიექტის (გამომცემლის) მდგომარეობის ცვლილებისას ავტომატურად იუწყებიან ყველა დამოკიდებული ობიექტი (გამწერი). გამოიყენება შეტყობინების სისტემებში, რეაქტიულ ინტერფეისებში.

// დაკვირვებლის გამოყენების მაგალითი
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("განახლება მიღებულია:", data);
  }
}

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

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

observable.notify("ახალი მონაცემები ხელმისაწვდომია!");

სტრატეგია (Strategy): ალგორითმების ოჯახი განსაზღვრა, თითოეული მათგანის კოდირება და მათ შორის არჩევანის გაკეთება. ალგორითმი დამოუკიდებლად იცვლება, რაც მომხმარებლებს არ ეხება. გამოიყენება მონაცემების დამუშავებისა და ოპერაციების შესრულებისთვის.

// სტრატეგიის გამოყენების მაგალითი
class PaymentStrategy {
  pay(amount) {
    throw new Error("მეთოდი არ არის განხორციელებული");
  }
}

class CreditCardPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`გადახდა ${amount} კრედიტ ბარათით`);
  }
}

class PayPalPayment extends PaymentStrategy {
  pay(amount) {
    console.log(`გადახდა ${amount} 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);

დეკორატორი (Decorator): დინამიურად ახალი ფუნქციონალობის დამატება ობიექტს მისი სტრუქტურის შეცვლის გარეშე. ობიექტის გადაფარვა და იგივე ინტერფეისის მიწოდება, მაგრამ დამატებული ფუნქციონალობით. სასარგებლოა ლოგგირებისთვის, ვალიდაციისთვის, კეშისთვის.

// დეკორატორის გამოყენების მაგალითი
class Component {
  operation() {
    return "ძირითადი კომპონენტი";
  }
}

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

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

class ConcreteDecoratorA extends Decorator {
  operation() {
    return `კონკრეტდეკორატორიA(${super.operation()})`;
  }
}

class ConcreteDecoratorB extends Decorator {
  operation() {
    return `კონკრეტდეკორატორიB(${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());

მოდული (Module): მიუხედავად იმისა, რომ Node.js-ში მოდულების სისტემა (CommonJS, ES Modules) ინტეგრირებულია, JavaScript-ში Module pattern (ძველი ნიმუში) გამოიყენებოდა პირად წევრებთან და პუბლიკურ ინტერფეისთან მუშაობისთვის. ეს არის ინკაფსულაციის საფუძველი.

ამ ნიმუშებმა დამეხმარა შექმნა უფრო სტრუქტურირებული, გაფართოებადი და შენარჩუნებადი კოდი.

რომელი დიზაინის ნიმუშები გამოიყენეთ პრაქტიკაში?