Fale sobre os padrões de projeto utilizados para…

Para otimizar a frequência de execução do código, muitas vezes são utilizados padrões de projeto que reduzem os custos gerais, evitam cálculos repetidos e gerenciam recursos de forma eficiente.

Padrões principais:

Singleton

Garante a criação de uma única instância de uma classe. É útil para acessar recursos compartilhados, como conexões a bancos de dados ou caches, evitando sua criação múltipla.

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

Armazenamento centralizado para objetos e serviços comuns. Permite acessar recursos já criados ou configurados sem necessidade de re-inicializá-los.

<?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
- Utilizado para gerir eficazmente uma grande quantidade de objetos pequenos com comportamentos semelhantes, partilhando o seu estado. Permite poupar memória e tempo na criação de objetos. Um exemplo pode ser o uso de objetos comuns para representar caracteres, cores, etc.
Proxy
- Fornece um substituto ou "representante" para outro objeto. Pode ser usado para carregamento diferido (Lazy Loading), quando o objeto é criado apenas na primeira vez que é acedido, ou para cachear resultados de operações.

Cache (ou Memoization - não exatamente um padrão, mas uma técnica)

Guardar os resultados de funções ou consultas dispendiosas para devolver o resultado armazenado em chamadas posteriores com os mesmos argumentos, em vez de recalcular. Frequentemente implementado dentro de outros padrões ou como um componente separado.

<?php
function expensiveFunction($arg) {
    static $cache = []; // Implementação simples de cache

    if (isset($cache[$arg])) {
        echo "A usar cache para $arg\n";
        return $cache[$arg];
    }

    echo "A calcular para $arg\n";
    // Simulação de operação dispendiosa
    sleep(1);
    $result = $arg * 2;
    $cache[$arg] = $result;

    return $result;
}

expensiveFunction(10); // Calcula e armazena em cache
expensiveFunction(10); // Usa o cache

Object Pool
- Armazena um conjunto de objetos prontos a usar, que podem ser reutilizados em vez de criados novamente. Útil para objetos dispendiosos de criar, como conexões a bases de dados.
Lazy Loading
- Princípio separado, frequentemente implementado com Factory, Proxy ou outros padrões. O objeto ou recurso é carregado apenas quando realmente necessário, reduzindo a carga inicial.

Cada um destes padrões ajuda a reduzir a redundância de operações, usar recursos de forma eficiente e, consequentemente, otimizar a frequência e velocidade de execução do código. A escolha do padrão depende da tarefa específica e do contexto.

Fale sobre os padrões de projeto utilizados para otimizar a frequência de execução do código.