Ի՞նչ նախագծման նմուշներ եք կիրառել պրակտիկայում։

Практиկայում ես կիրառել եմ հետևյալ նախագծման օրինակները:

1. Ֆաբրիկա մեթոդ (Factory Method): Օբյեկտների ստեղծման համար տարբեր տիպերի առանց կոնկրետ դասի նշելու։ Հարմար է տարբեր տվյալների աղբյուրների կամ կոնֆիգուրացիաների հետ աշխատելիս։

   // Օրինակ ֆաբրիկա մեթոդի օգտագործման
   class DataReader {
     read() {
       throw new Error("Method not implemented");
     }
   }
   
   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();
   

2. Միայնակ (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); // ճիշտ
   

3. Դիտորդ (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("Նոր տվյալներ հասանելի են!");
   

4. Երաշխավոր (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);
   

5. Դեկորատոր (Decorator): Օգտագործվում է դինամիկ ավելացնելու նոր ֆունկցիոնալություն օբյեկտին՝ առանց նրա կառուցվածքը փոխելու։ Օգտագործվում է լոգգավորման, վավերացման, կեշավորման համար։

   // Օրինակ դեկորատորի օգտագործման
   class Component {
     operation() {
       return "Հիմնական կոմպոնենտ";
     }
   }
   
   class Decorator {
     constructor(component) {
       this.component = component;
     }
   
     operation() {
       return this.component.operation();
     }
   }
   
   class ConcreteDecoratorA extends Decorator {
     operation() {
       return `ԿոնկրետDecoratorA(${super.operation()})`;
     }
   }
   
   class ConcreteDecoratorB extends Decorator {
     operation() {
       return `ԿոնկրետDecoratorB(${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());
   

6. Մոդուլ (Module): Թեև Node.js-ում մոդուլների համակարգը ներկառուցված է (CommonJS, ES Modules), JavaScript-ում Module pattern-ը օգտագործվում էր գաղտնի անդամների և հանրային ինտերֆեյսի ստեղծման համար։ Սա հիմք է կառուցելու ինկապսուլացված կոդի։

Այս պատկերները օգնել են ինձ ստեղծել ավելի կառուցվածքային, ընդլայնելի և պահպանվող կոդ։