Háblame de los patrones de diseño utilizados para…

Para optimizar la frecuencia de ejecución del código, a menudo se utilizan patrones de diseño que reducen los costos generales, evitan cálculos repetidos y gestionan eficientemente los recursos.

Patrones principales:

Singleton

Garantiza la creación de una sola instancia de una clase. Es útil para acceder a recursos compartidos, como conexiones a bases de datos o cachés, evitando su creación múltiple.

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

Almacén centralizado para objetos y servicios compartidos. Permite acceder a recursos ya creados o configurados sin necesidad de re-inicializarlos.

<?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
- Se utiliza para gestionar eficazmente una gran cantidad de objetos pequeños con comportamientos similares, compartiendo su estado. Permite ahorrar memoria y tiempo en la creación de objetos. Un ejemplo puede ser el uso de objetos compartidos para representar caracteres, colores, etc.
Proxy
- Proporciona un sustituto o "representante" para otro objeto. Puede usarse para carga diferida (Lazy Loading), cuando el objeto se crea solo en la primera vez que se accede a él, o para cachear resultados de operaciones.

Cache (o Memoization - no exactamente un patrón, sino una técnica)

Guardar los resultados de funciones o consultas costosas para devolver el resultado almacenado en llamadas posteriores con los mismos argumentos, en lugar de recalcular. Frecuentemente se implementa dentro de otros patrones o como un componente separado.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Implementación simple de caché

    if (isset($cache[$arg])) {
        echo "Usando caché para $arg\n";
        return $cache[$arg];
    }

    echo "Calculando para $arg\n";
    // Simulación de operación costosa
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Se calcula y se almacena en caché
expensiveFunction(10); // Se usa la caché

Object Pool
- Almacena un conjunto de objetos listos para usar, que pueden reutilizarse en lugar de crear nuevos. Es útil para objetos costosos de crear, como conexiones a bases de datos.
Lazy Loading
- Principio separado, a menudo implementado con Factory, Proxy u otros patrones. El objeto o recurso se carga solo cuando realmente se necesita, reduciendo la carga inicial.

Cada uno de estos patrones ayuda a reducir la redundancia de operaciones, usar los recursos de manera eficiente y, en consecuencia, optimizar la frecuencia y velocidad de ejecución del código. La elección del patrón depende de la tarea específica y del contexto.

Háblame de los patrones de diseño utilizados para optimizar la frecuencia de ejecución del código.