Çfarë është memoizimi dhe si e implementoni atë?

Question

Accepted Answer

**Memoizimi** i ruaj në cache rezultatet e një funksioni të indeksuar sipas argumenteve të tij, kështu që thirrjet e përsëritura me të njëjta inpute kthejnë rezultatin e ruajtur në cache në mënyrë të menjëhershme në vend që ta rillogaritni. Ai bën shkëmbim të **memories për shpejtësi** dhe funksionon vetëm për funksionet **pure** (i njëjti input → i njëjti output, pa efekte anësore).

## Një wrapper memoize gjenerik

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

## Një fitim klasik: Fibonacci rekursiv

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

## Këmbimet dhe paralajmërimet

- **Strategjia e çelësit të cache-it**: `JSON.stringify` dështon për funksionet, dhe rendi i çelësave ka rëndësi për objektet. Për argumentet e objektit, një `WeakMap` (i indeksuar sipas referencës) shmang rrjedhjet e memories.
- **Rritja e pakufizuar**: cache-i kurrë nuk zvogëlohet — përdorni një **LRU** cache për proceset me kohëzgjatje të gjatë.
- Memoizoni vetëm kur rillogaritja është vërtet e shtrenjtë dhe inputet përsëriten.

## Pse ka rëndësi

Memoizimi është kudo: `useMemo` i React-it/`React.memo`, seciilues Reselect, programim dinamik.

Koncepti (cache rezultate pure sipas input-it) është i njëjtë; arti është zgjedhja e çelësit dhe kufizimi i cache-it.