Vertel over ontwerppatronen die worden gebruikt om de…

Om de frequentie van code-uitvoering te optimaliseren, worden vaak ontwerp patronen gebruikt die de overhead verminderen, herhaalde berekeningen vermijden en resources efficiënt beheren.

Belangrijkste patronen:

Singleton

Zorgt voor het creëren van slechts één instantie van een klasse. Handig voor toegang tot gedeelde bronnen zoals databaseverbindingen of caches, en voorkomt dat ze meerdere keren worden gemaakt.

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

Gecentraliseerde opslag voor gedeelde objecten en services. Maakt toegang mogelijk tot reeds gemaakte of geconfigureerde resources zonder herinitialisatie.

<?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
- Wordt gebruikt voor het efficiënt beheren van een groot aantal kleine objecten met vergelijkbaar gedrag, door hun toestand te delen. Bespaart geheugen en tijd bij het maken van objecten. Een voorbeeld is het gebruik van gedeelde objecten voor het weergeven van identieke tekens, kleuren, etc.
Proxy
- Biedt een vervanger of "vertegenwoordiger" voor een ander object. Kan worden gebruikt voor Lazy Loading, waarbij het object pas wordt gemaakt bij het eerste gebruik, of voor het cachen van resultaten.

Cache (of Memoization - geen echt patroon, maar een techniek)

Slaat de resultaten op van dure functies of queries, zodat bij herhaalde aanroepen met dezelfde argumenten het opgeslagen resultaat wordt teruggegeven in plaats van opnieuw te berekenen. Wordt vaak geïmplementeerd binnen andere patronen of als een aparte component.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Eenvoudige cache-implementatie

    if (isset($cache[$arg])) {
        echo "Cache gebruiken voor $arg\n";
        return $cache[$arg];
    }

    echo "Berekenen voor $arg\n";
    // Imiteer dure operatie
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Wordt berekend en gecached
expensiveFunction(10); // Cache wordt gebruikt

Object Pool
- Bevat een pool van gereed-voor-gebruik-objecten die hergebruikt kunnen worden in plaats van nieuwe te maken. Handig voor objecten die kostbaar zijn om te maken, zoals databaseverbindingen.
Lazy Loading
- Een apart principe, vaak geïmplementeerd met Factory, Proxy of andere patronen. Het object of de resource wordt pas geladen wanneer het echt nodig is, wat de initiële belasting vermindert.

Elk van deze patronen helpt om redundantie van operaties te verminderen, resources efficiënt te gebruiken en zo de frequentie en snelheid van code-uitvoering te optimaliseren. De keuze van het patroon hangt af van de specifieke taak en context.

Vertel over ontwerppatronen die worden gebruikt om de frequentie van code-uitvoering te optimaliseren.