Erzählen Sie mir von Designmustern, die zur…

Um die Häufigkeit der Code-Ausführung zu optimieren, werden häufig Designmuster verwendet, die die Overheads reduzieren, wiederholte Berechnungen vermeiden und Ressourcen effizient verwalten.

Hauptmuster:

Singleton

Gewährleistet die Erstellung einer einzigen Instanz einer Klasse. Nützlich für den Zugriff auf gemeinsame Ressourcen wie Datenbankverbindungen oder Caches, um deren mehrfachen Erzeugung zu vermeiden.

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

Zentraler Speicher für gemeinsame Objekte und Dienste. Ermöglicht den Zugriff auf bereits erstellte oder konfigurierte Ressourcen, ohne sie neu initialisieren zu müssen.

<?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
- Wird verwendet, um eine große Anzahl kleiner Objekte mit ähnlichem Verhalten effizient zu verwalten, indem deren Zustand geteilt wird. Spart Speicher und Zeit bei der Objekterstellung. Ein Beispiel ist die Verwendung gemeinsamer Objekte zur Darstellung identischer Zeichen, Farben usw.
Proxy
- Bietet einen Stellvertreter oder "Vertreter" für ein anderes Objekt. Kann für Lazy Loading verwendet werden, bei dem das Objekt erst beim ersten Zugriff erstellt wird, oder für das Zwischenspeichern von Operationsergebnissen.

Cache (oder Memoization - kein echtes Muster, sondern eine Technik)

Speichert die Ergebnisse teurer Funktionen oder Abfragen, um bei wiederholtem Aufruf mit denselben Argumenten das gespeicherte Ergebnis zurückzugeben, anstatt neu zu berechnen. Wird häufig in anderen Mustern oder als eigenständige Komponente implementiert.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Einfache Cache-Implementierung

    if (isset($cache[$arg])) {
        echo "Cache verwenden für $arg\n";
        return $cache[$arg];
    }

    echo "Berechnung für $arg\n";
    // Simulation einer teuren Operation
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Berechnet und cached
expensiveFunction(10); // Verwendet Cache

Object Pool
- Speichert einen Pool von einsatzbereiten Objekten, die wiederverwendet werden können, anstatt neue zu erstellen. Nützlich für teure Objekte wie Datenbankverbindungen.
Lazy Loading
- Separates Prinzip, das häufig mit Factory, Proxy oder anderen Mustern umgesetzt wird. Das Objekt oder die Ressource wird nur geladen, wenn es wirklich benötigt wird, um die Anfangslast zu verringern.

Jedes dieser Muster hilft, Redundanz zu verringern, Ressourcen effizient zu nutzen und somit die Häufigkeit und Geschwindigkeit der Code-Ausführung zu optimieren. Die Wahl des Musters hängt von der konkreten Aufgabe und dem Kontext ab.

Erzählen Sie mir von Designmustern, die zur Optimierung der Ausführungsfrequenz von Code verwendet werden.