मेमोइजेशन म्हणजे काय आणि त्याची अंमलबजावणी कशी करायची?

Question

Accepted Answer

**Memoization** एक फंक्शनचे परिणाम त्याच्या argument द्वारे की केलेले cache करते, त्यामुळे एकच input सह पुनरावृत्ती call केल्यास cached परिणाम तक्षणी परत येतो पुन्हा computing करण्याऐवजी. ते **memory साठी speed** trade करते आणि केवळ **pure** functions साठी काम करते (समान input → समान output, side effects नाहीत).

## सामान्य 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
```

## क्लासिक विजय: recursive 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
```

## Trade-offs आणि सतर्कता

- **Cache key strategy**: `JSON.stringify` functions साठी अयशस्वी होते, आणि objects साठी key order महत्वाचा आहे. object arguments साठी, `WeakMap` (reference द्वारे key केलेला) memory leaks टाळतो.
- **Unbounded growth**: cache कधीही shrink होत नाही — long-running processes साठी **LRU** cache वापरा.
- केवळ मेमोइज करा जेव्हा recomputation खरोखर महाग असेल आणि inputs पुनरावृत्ती होत असेल.

## हे महत्वाचे का आहे

Memoization सर्वत्र आहे: React `useMemo`/`React.memo`, Reselect selectors, dynamic programming.

कल्पना (pure परिणाम input द्वारे cache करणे) समान आहे; कला key निवडणे आणि cache bound करणे आहे.