Խոսեք ծրագրավորման հաճախականությունը օպտիմալացնելու համար օգտագործվող նախագծման նմուշների մասին։

Կոդի կատարման հաճախականությունը օպտիմալացնելու համար հաճախ օգտագործվում են նախագծման նմուշներ, որոնք նպատակ ունեն նվազեցնել ծախսերը, խուսափել կրկնվող հաշվարկներից և արդյունավետ կառավարել ռեսուրսները:

Հիմնական նմուշները՝

1. Singleton

   • ապահովում է, որ միայն մեկ օրինակ ստեղծվի դասից։ Օգտակար է ընդհանուր ռեսուրսներին, ինչպիսիք են տվյալների բազայի կապերը կամ cache-ը, մանավանդ երբ խուսափում ենք դրանց բազմակի ստեղծումից։

   <?php
   class Singleton {
       private static $instance = null;
       private function __construct() { /* ... */ }
       private function __clone() { /* ... */ }
       private function __wakeup() { /* ... */ }
   
       public static function getInstance(): self {
           if (self::$instance === null) {
               self::$instance = new self();
           }
           return self::$instance;
       }
   }
   

2. Registry

   • Կենտրոնական պահոց՝ ընդհանուր օբյեկտների և ծառայությունների համար։ Հնարավորություն է տալիս մուտք ունենալ արդեն ստեղծված կամ կոնֆիգուրացված ռեսուրսներին առանց նորից սկսելու։

   <?php
   class Registry {
       private static $data = [];
   
       public static function set(string $key, $value): void {
           self::$data[$key] = $value;
       }
   
       public static function get(string $key) {
           return self::$data[$key] ?? null;
       }
   
       public static function has(string $key): bool {
           return isset(self::$data[$key]);
       }
   }
   

3. Flyweight

   • արդյունավետ կառավարման մեթոդ մեծ թվով փոքր օբյեկտների, որոնք ունեն նման վարքագիծ, բաժանելով նրանց վիճակը։ Սա խնայում է հիշողությունը և ժամանակը օբյեկտների ստեղծման համար։ Օրինակ, ընդհանուր օբյեկտների օգտագործումը նույն նշանների, գույների և այլնի ներկայացման համար։

4. Proxy

   • փոխարինող կամ "ներկայացուցիչ" այլ օբյեկտի համար։ Կարող է օգտագործվել հետաձգված բեռնում (Lazy Loading), երբ օբյեկտը ստեղծվում է միայն առաջին դիմումի ժամանակ, կամ արդյունքների կեշավորման համար։

5. Cache (կամ Memoization - ոչ ամբողջությամբ նմուշ, այլ տեխնիկա)

   • արդյունքների պահպանում ծախսատար ֆունկցիաների կամ հարցումների, որպեսզի կրկնակի կանչի դեպքում վերադառնա պահպանումը, փոխարենը կրկնվող հաշվարկի։ Հաճախ իրականացնում է այլ նմուշների շրջանակներում կամ որպես առանձին կոմպոնենտ։

   <?php
   function expensiveFunction($arg) {
       static $cache = []; // պարզ cache
   
       if (isset($cache[$arg])) {
           echo "Cache- ի օգտագործում $arg\n";
           return $cache[$arg];
       }
   
       echo "Հաշվարկ $arg\n";
       // Խոշոր գործառույթի իմիտացիա
       sleep(1);
       $result = $arg * 2;
       $cache[$arg] = $result;
   
       return $result;
   }
   
   expensiveFunction(10); // Հաշվարկ և cache
   expensiveFunction(10); // Օգտագործում cache
   

6. Object Pool

   • պահպանում է պատրաստի օգտագործման օբյեկտների պուլը, որոնք կարող են կրկին օգտագործվել՝ փոխարենը նորից ստեղծելու։ Օգտակար է այն օբյեկտների համար, որոնց ստեղծումը ծախսատար է, օրինակ՝ կապեր տվյալների բազայի հետ։

7. Lazy Loading

   • առանձին սկզբունք, որը հաճախ իրականացնում է Factory, Proxy կամ այլ նմուշների միջոցով։ Օբյեկտը կամ ռեսուրսը միայն այն ժամանակ է բեռնվում, երբ իսկապես անհրաժեշտ է, նվազեցնելով սկզբնական բեռը։

Յուրաքանչյուր այս նմուշը օգնում է նվազեցնել ավելորդ գործողությունները, արդյունավետ օգտագործել ռեսուրսները և, հետևաբար, օպտիմալացնել կոդի կատարման հաճախականությունն ու արագությունը։ Նմուշի ընտրությունը կախված է կոնկրետ խնդիրից և կոնտեքստից։