Memorização em JavaScript

A memorização (ou "memoization") é uma técnica de otimização que armazena os resultados de funções pesadas ou demoradas em cache, para que chamadas futuras com os mesmos argumentos sejam mais rápidas. A memorização é especialmente útil em funções puras, onde o mesmo conjunto de entradas sempre produz o mesmo resultado.

Como Funciona a Memorização?

Quando uma função memorizada é chamada pela primeira vez com determinados argumentos, ela executa o cálculo e armazena o resultado em um cache. Em chamadas subsequentes com os mesmos argumentos, a função retorna o resultado diretamente do cache, evitando o cálculo repetido.

Implementação Básica de Memorização

function memoize(fn) {
  const cache = {};

  return function(...args) {
    const key = JSON.stringify(args); // Cria uma chave única para os argumentos

    if (cache[key]) {
      console.log("Resultado em cache");
      return cache[key]; // Retorna o valor armazenado no cache
    }

    const result = fn(...args); // Calcula o valor
    cache[key] = result; // Armazena o resultado no cache

    return result;
  };
}

Exemplo de uso:

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

const memoizedFactorial = memoize(factorial);

console.log(memoizedFactorial(5)); // Calcula e armazena em cache
console.log(memoizedFactorial(5)); // Recupera do cache

Benefícios da Memorização

• Redução de Processamento: Evita cálculos repetidos, o que melhora o desempenho.
• Ideal para Funções Recursivas: Acelera o processamento de funções que precisam ser chamadas várias vezes com os mesmos valores.
• Eficiente em Funções Puras: A memorização funciona melhor quando a função retorna o mesmo valor para os mesmos argumentos. Aplicações Comuns da Memorização
• Cálculos Matemáticos: Como fatorial, Fibonacci, etc.
• Chamadas de API: Evita chamadas de API duplicadas com os mesmos parâmetros.
• Operações de Custo Alto: Processamento de dados e manipulações complexas.

Resumo
A memorização em JavaScript é uma técnica poderosa para melhorar a eficiência do código e acelerar o desempenho em operações repetitivas e de alto custo computacional.