Parlami dei modelli di progettazione utilizzati per…

Per ottimizzare la frequenza di esecuzione del codice, vengono spesso utilizzati pattern di progettazione che riducono i costi generali, evitano calcoli ripetuti e gestiscono efficacemente le risorse.

Pattern principali:

Singleton

Garantisce la creazione di una sola istanza di una classe. È utile per accedere a risorse condivise, come connessioni a database o cache, evitando la loro creazione multipla.

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

Magazzino centralizzato per oggetti e servizi condivisi. Permette di accedere a risorse già create o configurate senza doverle reinizializzare.

<?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
- Viene utilizzato per gestire in modo efficiente un gran numero di piccoli oggetti con comportamenti simili, condividendo il loro stato. Permette di risparmiare memoria e tempo nella creazione di oggetti. Un esempio può essere l'uso di oggetti condivisi per rappresentare caratteri, colori, ecc.
Proxy
- Fornisce un sostituto o "rappresentante" per un altro oggetto. Può essere usato per il caricamento lazy (Lazy Loading), quando l'oggetto viene creato solo al primo accesso, o per la cache dei risultati delle operazioni.

Cache (o Memoization - non propriamente un pattern, ma una tecnica)

Conserva i risultati di funzioni o query costose, restituendo il risultato memorizzato nelle chiamate successive con gli stessi argomenti, invece di ricalcolare. Spesso viene implementato all'interno di altri pattern o come componente separato.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Implementazione semplice di cache

    if (isset($cache[$arg])) {
        echo "Utilizzo della cache per $arg\n";
        return $cache[$arg];
    }

    echo "Calcolo per $arg\n";
    // Simulazione di operazione costosa
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Calcola e memorizza in cache
expensiveFunction(10); // Usa la cache

Object Pool
- Memorizza un pool di oggetti pronti all'uso, che possono essere riutilizzati invece di crearne di nuovi. Utile per oggetti costosi da creare, come connessioni a database.
Lazy Loading
- Principio separato, spesso implementato con Factory, Proxy o altri pattern. L'oggetto o la risorsa viene caricata solo quando è realmente necessario, riducendo il carico iniziale.

Ognuno di questi pattern aiuta a ridurre la ridondanza delle operazioni, a usare le risorse in modo efficiente e, di conseguenza, a ottimizzare la frequenza e la velocità di esecuzione del codice. La scelta del pattern dipende dal compito specifico e dal contesto.

Parlami dei modelli di progettazione utilizzati per ottimizzare la frequenza di esecuzione del codice.