Memoization em javascript. Como acelerar funções lentas.

Memoization é uma técnica de otimização utilizada para fazer com que funções lentas fiquem mais rápida. A técnica consiste em armazenar o resultado de uma execução para que, no caso da mesma ser executada novamente com os mesmos parâmetros, o resultado esteja disponível sem a necessidade de executar a função novamente.

Implementar memoization em javascript é MUITO fácil. A primeira coisa que é preciso entender é que em javascript, uma função (assim como qualquer outro objeto) poder ter atributos, como podemos ver abaixo:

var minhaFuncao = function(){
  return "hello";
};
minhaFuncao.foo = "bar";
console.log(minhaFuncao()); // Imprime hello
console.log(minhaFuncao.foo); // Imprime bar

Pode parecer estranho, mas graças a esse aspecto da linguagem podemos construir coisas muito poderosas, como memoization. Para exemplificar essa técnica, vamos construir uma função que calcule o fatorial de um número:

var fatorial = function(n){
  if(n===0){
   return 1;
  }
  return n*fatorial(n-1);
};
// E podemos executar como 
fatorial(0); //1
fatorial(1); //1
fatorial(2); //2
fatorial(3); //6

Este é um fatorial recursivo básico, como todos já conhecemos. Se quisermos acrescentar memoization nessa função, temos que de alguma forma armazenar o resultado das execuções anteriores, e como você já deve estar imaginando, vamos armazenar como propriedades na própria função:

var fatorial = function(n){
  if(fatorial[n]){
    return fatorial[n];
  }
  if(n===0){
    return 1;
  }
  fatorial[n] = n*fatorial(n-1);
  return fatorial[n];
};
// E podemos executar como 
fatorial(0); //1
fatorial(1); //1
fatorial(2); //2
fatorial(3); //6

Note que tudo o que tivemos que fazer foi adicionar um if para verificar se a função já havia sido calculada para aquele valor e armazenar o resultado antes do retorno. Fazendo um chinês da função é fácil notar que ao executarmos novamente fatorial(3) o valor já está armazenado e não é necessário calcular novamente assim como a execução de fatorial(4) resulta em somente uma recursão, já que o resultado de fatorial(4 -1) já está armazenado.

Este é só um exemplo básico, mas que já dá uma noção do poder da técnica. Use-a em casos de processamento muito pesado para salvar muitos ciclos da sua CPU :)