Vad är memoization och hur implementerar du det?

Question

Accepted Answer

**Memoization** cachelagrar en funktions resultat indexerat efter dess argument, så upprepade anrop med samma inmatningar returnerar det cachelagrat resultatet direkt istället för att räkna om. Det byter **minne för hastighet** och fungerar bara för **rena** funktioner (samma inmatning → samma utmatning, inga bieffekter).

## En generisk memoize-wrapper

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

## En klassisk vinst: rekursiv Fibonacci

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

## Avvägningar och varningar

- **Cache-nyckelstrategi**: `JSON.stringify` fungerar inte för funktioner, och nyckelordning spelar roll för objekt. För objektargument undviker en `WeakMap` (indexerad efter referens) minnesläckor.
- **Obegränsad tillväxt**: cachen krymper aldrig — använd en **LRU**-cache för långvariga processer.
- Memoiza bara när omräkning är verkligt dyr och inmatningar upprepas.

## Varför det spelar roll

Memoization är överallt: Reacts `useMemo`/`React.memo`, Reselect-väljare, dynamisk programmering.

Konceptet (cachelagra rena resultat efter inmatning) är detsamma; konsten ligger i att välja nyckeln och begränsa cachen.