Pastāstiet par dizaina modeļiem, kas tiek izmantoti, lai optimizētu koda izpildes biežumu.

Koda izpildes biežuma optimizēšanai bieži tiek izmantoti projektēšanas modeļi, kas vērsti uz papildu izmaksu samazināšanu, atkārtotu aprēķinu novēršanu un resursu efektīvu pārvaldību.

Galvenie modeļi:

1. Singleton

   • Nodrošina tikai viena objekta izveidi. Noderīgs kopēju resursu, piemēram, datu bāzes savienojumu vai kešatmiņas, piekļuvei, novēršot to daudzreizēju izveidi.

   <?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

   • Centralizēta glabātuve kopīgiem objektiem un pakalpojumiem. ļauj piekļūt iepriekš izveidotiem vai konfigurētiem resursiem bez to atkārtotas inicializācijas.

   <?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

   • Efektīvi pārvalda lielu skaitu nelielu objektu ar līdzīgu uzvedību, daloties to stāvoklī. Tas ļauj ietaupīt atmiņu un laiku, izveidojot objektus. Piemēram, kopēju objektu izmantošana, lai attēlotu vienādus simbolus, krāsas utt.

4. Proxy

   • Nodrošina aizstājēju vai "aizstājēju" citam objektam. To var izmantot aizkavētas ielādes (Lazy Loading) gadījumā, kad objekts tiek izveidots tikai pirmās piekļuves brīdī, vai rezultātu kešatmiņai.

5. Cache (vai Memoization - ne pilnīgs modelis, drīzāk tehnika)

   • Dārgu funkciju vai pieprasījumu rezultātu saglabāšana, lai atkārtoti izsaucot ar tiem pašiem argumentiem, tiktu atgriezts saglabātais rezultāts, nevis atkārtoti aprēķināts. Bieži tiek realizēts kā citu modeļu daļa vai kā atsevišķa komponenta.

   <?php
   function expensiveFunction($arg) {
       static $cache = []; // Vienkārša kešatmiņas realizācija
   
       if (isset($cache[$arg])) {
           echo "Using cache for $arg\n";
           return $cache[$arg];
       }
   
       echo "Calculating for $arg\n";
       // Dārga operācija imitācija
       sleep(1);
       $result = $arg * 2;
       $cache[$arg] = $result;
   
       return $result;
   }
   
   expensiveFunction(10); // Aprēķina un saglabā kešā
   expensiveFunction(10); // Izmanto kešu
   

6. Object Pool

   • Glabā gatavus lietošanai objektu baseinus, kurus var atkārtoti izmantot, neizveidojot jaunus. Noderīgi dārgiem objektiem, piemēram, datu bāzes savienojumiem.

7. Lazy Loading

   • Atsevišķs princips, bieži realizēts ar Factory, Proxy vai citiem modeļiem. Objekts vai resurss tiek ielādēts tikai tad, kad tas ir patiešām nepieciešams, samazinot sākotnējo slodzi.

Katrs no šiem modeļiem palīdz samazināt liekas operācijas, efektīvi izmantot resursus un, kā rezultātā, optimizēt koda izpildes biežumu un ātrumu. Modeļa izvēle ir atkarīga no konkrētās uzdevuma un konteksta.