Meséljen a kód végrehajtási gyakoriságának…

A kód futási gyakoriságának optimalizálásához gyakran alkalmaznak tervezési mintákat, amelyek célja a túlzott költségek csökkentése, az ismételt számítások elkerülése és az erőforrások hatékony kezelése.

Fő minták:

Singleton

Biztosítja, hogy csak egy példány jöjjön létre egy osztályból. Hasznos közös erőforrásokhoz való hozzáféréshez, például adatbázis-kapcsolatokhoz vagy cache-hez, elkerülve azok többszöri létrehozását.

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

Központi tároló közös objektumok és szolgáltatások számára. Lehetővé teszi, hogy hozzáférjünk korábban létrehozott vagy konfigurált erőforrásokhoz anélkül, hogy újra inicializálnánk őket.

<?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
- Hatékonyan kezeli a sok kis, hasonló viselkedésű objektumot, megosztva azok állapotát. Ez memória- és időmegtakarítást eredményezhet, például azonos karakterek, színek közös reprezentációja.
Proxy
- Egy másik objektum helyettesítője vagy "helyettesítője". Használható késleltetett betöltéshez (Lazy Loading), amikor az objektum csak az első hozzáféréskor jön létre, vagy eredmények cache-eléséhez.

Cache (vagy Memoization - nem teljesen mintázat, inkább technika)

Eredmények tárolása költséges függvények vagy lekérdezések esetén, hogy ismételt híváskor a tárolt eredményt adjuk vissza, ahelyett, hogy újra számolnánk. Gyakran más minták keretében vagy külön komponensként valósul meg.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Egyszerű cache

    if (isset($cache[$arg])) {
        echo "Cache használata $arg esetén\n";
        return $cache[$arg];
    }

    echo "Számítás $arg esetén\n";
    // Költséges művelet imitációja
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Számítás és cache
expensiveFunction(10); // Cache használata

Object Pool
- Kész objektumok poolját tartja, amelyeket újra felhasználhatunk ahelyett, hogy újak lennének. Hasznos például költséges objektumok, például adatbázis-kapcsolatok esetén.
Lazy Loading
- Egy különálló elv, gyakran Factory, Proxy vagy más minták segítségével valósítják meg. Az objektum vagy erőforrás csak akkor töltődik be, amikor valóban szükség van rá, csökkentve a kezdeti terhelést.

Minden ilyen minta segít csökkenteni a felesleges műveleteket, hatékonyan használni az erőforrásokat, és ezáltal optimalizálni a kód futási gyakoriságát és sebességét. A minta kiválasztása a konkrét feladattól és kontextustól függ.

Meséljen a kód végrehajtási gyakoriságának optimalizálására használt tervezési mintákról.