Vorbește despre modelele de proiectare utilizate…

Pentru a optimiza frecvența de execuție a codului, se utilizează adesea modele de proiectare care reduc costurile generale, evită calculele repetitive și gestionează eficient resursele.

Modele principale:

Singleton

Asigură crearea unei singure instanțe a unei clase. Este util pentru accesul la resurse comune, cum ar fi conexiuni la baze de date sau cache-uri, evitând crearea multiplă.

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

Registry

Depozit centralizat pentru obiecte și servicii comune. Permite accesul la resursele deja create sau configurate fără a fi nevoie de reinițializare.

<?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]);
    }
}

Flyweight
- Este utilizat pentru gestionarea eficientă a unui număr mare de obiecte mici cu comportament similar, împărțind starea lor. Permite economisirea memoriei și timpul de creare a obiectelor. Un exemplu poate fi utilizarea obiectelor comune pentru reprezentarea aceluiași caracter, culori etc.
Proxy
- Oferă un înlocuitor sau "reprezentant" pentru alt obiect. Poate fi utilizat pentru încărcare întârziată (Lazy Loading), când obiectul este creat doar la primul acces sau pentru cache-ul rezultatelor operațiilor.

Cache (sau Memoization - nu chiar un pattern, ci o tehnică)

Salvează rezultatele funcțiilor sau interogărilor costisitoare pentru a returna rezultatul salvat în cazul apelurilor ulterioare cu aceiași parametri, în loc să recalculze. Este adesea implementat în cadrul altor pattern-uri sau ca un component separat.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Implementare simplă a cache-ului

    if (isset($cache[$arg])) {
        echo "Utilizare cache pentru $arg\n";
        return $cache[$arg];
    }

    echo "Calcul pentru $arg\n";
    // Simulare operație costisitoare
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Se calculează și se cachează
expensiveFunction(10); // Se folosește cache-ul

Object Pool
- Păstrează un pool de obiecte gata de utilizare, care pot fi reutilizate în loc să fie create din nou. Este util pentru obiecte costisitoare de creat, cum ar fi conexiunile la baze de date.
Lazy Loading
- Un principiu separat, adesea implementat cu Factory, Proxy sau alte pattern-uri. Obiectul sau resursa este încărcată doar atunci când este cu adevărat necesar, reducând sarcina inițială.

Fiecare dintre aceste pattern-uri ajută la reducerea redundanței operațiilor, utilizarea eficientă a resurselor și, ca urmare, la optimizarea frecvenței și vitezei de execuție a codului. Alegerea pattern-ului depinde de sarcina specifică și de context.

Vorbește despre modelele de proiectare utilizate pentru a optimiza frecvența de execuție a codului.