Cos'è la memoization e come la implementi?

Question

Accepted Answer

**Memoization** memorizza nella cache i risultati di una funzione con chiave basata sui suoi argomenti, quindi le chiamate ripetute con gli stessi input restituiscono istantaneamente il risultato in cache invece di ricalcolare. Scambia **memoria per velocità** e funziona solo per funzioni **pure** (stesso input → stesso output, nessun effetto collaterale).

## Un wrapper memoize generico

```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 vittoria classica: Fibonacci ricorsivo

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

## Compromessi e avvertenze

- **Strategia della chiave cache**: `JSON.stringify` fallisce per le funzioni e l'ordine delle chiavi è importante per gli oggetti. Per gli argomenti oggetto, `WeakMap` (con chiave per riferimento) evita perdite di memoria.
- **Crescita illimitata**: la cache non si riduce mai — usa una cache **LRU** per processi a lungo termine.
- Memoizza solo quando il ricalcolo è realmente costoso e gli input si ripetono.

## Perché è importante

La memoization è ovunque: React `useMemo`/`React.memo`, selettori Reselect, programmazione dinamica.

Il concetto (risultati puri della cache per input) è lo stesso; l'arte consiste nel scegliere la chiave e limitare la cache.