Parlez-moi des modèles de conception utilisés pour…

Pour optimiser la fréquence d'exécution du code, on utilise souvent des modèles de conception visant à réduire les coûts, éviter les calculs répétés et gérer efficacement les ressources.

Principaux modèles:

Singleton

Garantit la création d'une seule instance d'une classe. Utile pour accéder à des ressources partagées, comme des connexions à une base de données ou des caches, en évitant leur création multiple.

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

Stockage centralisé pour des objets et services communs. Permet d'accéder à des ressources déjà créées ou configurées sans avoir à les réinitialiser.

<?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
- Utilisé pour gérer efficacement un grand nombre de petits objets avec un comportement similaire, en partageant leur état. Permet d'économiser de la mémoire et du temps lors de la création d'objets. Un exemple peut être l'utilisation d'objets communs pour représenter des caractères, des couleurs, etc.
Proxy
- Fournit un substitut ou un "représentant" pour un autre objet. Peut être utilisé pour le chargement différé (Lazy Loading), lorsque l'objet n'est créé que lors de la première utilisation, ou pour mettre en cache les résultats des opérations.

Cache (ou Memoization - pas tout à fait un pattern, mais une technique)

Enregistrement des résultats de fonctions ou requêtes coûteuses pour retourner le résultat stocké lors d'appels ultérieurs avec les mêmes arguments, au lieu de recalculer. Souvent intégré dans d'autres patterns ou comme composant séparé.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Implémentation simple du cache

    if (isset($cache[$arg])) {
        echo "Utilisation du cache pour $arg\n";
        return $cache[$arg];
    }

    echo "Calcul pour $arg\n";
    // Simulation d'une opération coûteuse
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Calcul et mise en cache
expensiveFunction(10); // Utilisation du cache

Object Pool
- Stocke un pool d'objets prêts à l'emploi, qui peuvent être réutilisés au lieu d'être recréés. Utile pour des objets coûteux à créer, comme des connexions à une base de données.
Lazy Loading
- Principe séparé, souvent implémenté avec Factory, Proxy ou d'autres patterns. L'objet ou la ressource est chargé uniquement lorsque cela est nécessaire, réduisant la charge initiale.

Chacun de ces patterns aide à réduire la redondance des opérations, à utiliser efficacement les ressources et, par conséquent, à optimiser la fréquence et la vitesse d'exécution du code. Le choix du pattern dépend de la tâche spécifique et du contexte.

Parlez-moi des modèles de conception utilisés pour optimiser la fréquence d'exécution du code.