Qu'est-ce que la mémoïsation et comment l'implémenter ?

Question

Accepted Answer

**Memoization** met en cache les résultats d'une fonction indexés par ses arguments, de sorte que les appels répétés avec les mêmes entrées retournent immédiatement le résultat en cache au lieu de recalculer. Elle échange **de la mémoire contre de la vitesse** et ne fonctionne que pour les fonctions **pures** (même entrée → même sortie, pas d'effets secondaires).

## Un wrapper memoize générique

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

## Une victoire classique : Fibonacci récursif

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

## Compromis et mises en garde

- **Stratégie des clés de cache** : `JSON.stringify` échoue pour les fonctions, et l'ordre des clés importe pour les objets. Pour les arguments objets, une `WeakMap` (indexée par référence) évite les fuites mémoire.
- **Croissance non bornée** : le cache ne rétrécit jamais — utilisez un cache **LRU** pour les processus longue durée.
- Mémoïsez uniquement quand le recalcul est vraiment coûteux et les entrées se répètent.

## Pourquoi c'est important

La mémoïsation est partout : les `useMemo`/`React.memo` de React, les sélecteurs Reselect, la programmation dynamique.

Le concept (mettre en cache les résultats purs par entrée) est le même ; l'art consiste à choisir la clé et à borner le cache.