O que é memoização e como você a implementa?

Question

Accepted Answer

**Memoização** armazena os resultados de uma função em cache, indexados por seus argumentos, de modo que chamadas repetidas com as mesmas entradas retornam o resultado em cache instantaneamente em vez de recalcular. Ela troca **memória por velocidade** e funciona apenas com funções **puras** (mesma entrada → mesma saída, sem efeitos colaterais).

## Um wrapper memoize genérico

```js
function memoize(fn) {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args); // build a cache key from the arguments
    if (cache.has(key)) {
      return cache.get(key);          // cache hit — skip the work
    }
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
}

const slowSquare = n => { /* expensive */ return n * n; };
const fastSquare = memoize(slowSquare);
fastSquare(4); // computes → 16
fastSquare(4); // cached → 16 instantly
```

## Uma vitória clássica: Fibonacci recursivo

```js
const fib = memoize(n => (n < 2 ? n : fib(n - 1) + fib(n - 2)));
// turns exponential O(2^n) into roughly O(n) by caching subproblems
```

## Trade-offs e ressalvas

- **Estratégia de chave de cache**: `JSON.stringify` falha para funções, e a ordem das chaves importa para objetos. Para argumentos de objeto, um `WeakMap` (indexado por referência) evita vazamentos de memória.
- **Crescimento ilimitado**: o cache nunca diminui — use um cache **LRU** para processos de longa duração.
- Memoize apenas quando o recálculo é genuinamente caro e as entradas se repetem.

## Por que isso importa

Memoização está em toda parte: `useMemo` e `React.memo` do React, seletores Reselect, programação dinâmica.

O conceito (cache de resultados puros por entrada) é o mesmo; a arte está em escolher a chave e limitar o cache.