¿Qué es la memoización y cómo se implementa?

Question

Accepted Answer

La **memoización** almacena en caché los resultados de una función indexados por sus argumentos, de modo que las llamadas repetidas con las mismas entradas devuelven el resultado cacheado al instante en lugar de recalcularlo. Intercambia **memoria por velocidad** y solo funciona para funciones **puras** (misma entrada → misma salida, sin efectos secundarios).

## Un wrapper genérico de memoize

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

## Una victoria clásica: 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
```

## Compensaciones y advertencias

- **Estrategia de clave de caché**: `JSON.stringify` falla con funciones, y el orden de las claves importa para los objetos. Para argumentos que son objetos, un `WeakMap` (indexado por referencia) evita las fugas de memoria.
- **Crecimiento sin límites**: la caché nunca se reduce — usa una caché **LRU** para procesos de larga duración.
- Memoiza solo cuando recalcular sea genuinamente costoso y las entradas se repitan.

## Por qué es importante

La memoización está en todas partes: `useMemo`/`React.memo` de React, los selectores de Reselect, la programación dinámica.

El concepto (cachear resultados puros por entrada) es el mismo; el arte está en elegir la clave y acotar la caché.