Ce este memoizarea și cum o implementezi?

Question

Accepted Answer

**Memoizarea** cachează rezultatele unei funcții indexate după argumentele sale, astfel încât apelurile repetate cu aceleași intrări returnează rezultatul din cache instantaneu în loc să recalculeze. Ea face un schimb între **memorie și viteză** și funcționează doar pentru funcții **pure** (aceeași intrare → aceeași ieșire, fără efecte secundare).

## Un wrapper generic 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
```

## O victorie clasică: Fibonacci recursiv

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

## Compromisuri și cavitate

- **Strategie cheie cache**: `JSON.stringify` eșuează pentru funcții, iar ordinea cheilor contează pentru obiecte. Pentru argumente de obiecte, o `WeakMap` (indexată după referință) evită scurgerile de memorie.
- **Creștere nelimitată**: cache-ul nu se micșorează niciodată — folosește un cache **LRU** pentru procese de lungă durată.
- Memoizează doar când recalcularea este cu adevărat costisitoare și intrările se repetă.

## De ce contează

Memoizarea este peste tot: `useMemo`/`React.memo` al React, selectori Reselect, programare dinamică.

Conceptul (cachează rezultatele pure după intrare) este același; arta constă în alegerea cheii și limitarea cache-ului.