Otimização de métodos PHP com cache de resultados

Existem métodos que calculam uma informação de acordo com parâmetros informados (ou não) e retornam um resultado. Para alguns destes métodos, pode ser útil utilizar um cache de resultados para otimizar chamadas sucessivas ao método com parâmetros idênticos.

Para prover a otimização destes métodos, é utilizada uma variável estática que guarda os resultados já calculados.

Assim, antes de calcular um resultado, é verificado se ele já foi calculado. Veja um exemplo:

/**
 * Funcao sem otimizacao
 */
function fazer_conta($x, $y) {
    return ($x + $y) * ($x - y) / 2;
}

/**
 * Funcao com otimizacao
 */
function fazer_conta($x, $y) {
    static $resultados = array();

    // Se ainda nao calculou o resultado para os parametros informados
    if (!isset($resultados[$x][$y])) {
        $resultados[$x][$y] = ($x + $y) * ($x - y) / 2;
    }

    // Retorna o resultado calculado
    return $resultados[$x][$y];
}

A forma como os parâmetros são indexados no array de resultados pode ser feita de outra maneira. Pode ser feito um hash único dos parâmetros da seguinte forma:

function exemplo($x, $y) {
    static resultados = array();
    $hash = serialize(func_get_args());
    if (!isset($resultados[$hash])) {
        $resultados[$hash] = ...
    }
    return $resultados[$hash];
}

Em alguns casos, pode ser útil forçar que o cálculo seja feito. Isso pode ser controlado por um parâmetro ou por um método, caso esteja tratando de um método de classe:

class exemplo {
    static $resultados = array();

    public static function calcular($x, $y) {
        if (!isset($resultados[$x][$y])) {
            self::$resultados[$x][$y] = ...
        }
        return self::$resultados[$x][$y];
    }

    public static function limparCache() {
        self::$resultados = array();
    }

}

Isso pode ocorrer, por exemplo, em um método que devolve o tamanho de uma imagem. A princípio, o valor não precisa ser recalculado, porém, entre uma chamada à função e outra, a imagem pode ter sofrido uma mudança. Para isso, pode-se limpar a cache ou levar em consideração a data de modificação do arquivo no momento que a informação foi obtida. Caso o arquivo não tenha sido modificado, o tamanho da imagem continua o mesmo.

O importante é que o mecanismo para guardar a informação em cache e a indexação não seja muito complexa, caso contrário, o método fica mais lento do que se não fosse otimizado.