Memoization શું છે અને તમે તેને કેવી રીતે લાગુ કરો છો?

Question

Accepted Answer

**Memoization** ફંક્શનના પરિણામોને તેના દલીલો દ્વારા કીજ્ഞાપિત કરે છે, તેથી સમાન ઇનપુટ સાથે વારંવાર કॉલ તરત જ કેશ્ડ પરિણામ પરત કરે છે બદલે ફરીથી ગણતરી કરવાની જગાએ. તે **મેમરી વિનિમય ગતિ** માટે હાલાકી કરે છે અને માત્ર **શુદ્ધ** ફંક્શન્સ માટે કામ કરે છે (સમાન ઇનપુટ → સમાન આઉટપુટ, કોઈ આડઅસર નહીં).

## એક સામાન્ય 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
```

## એક શાસ્ત્રીય જીત: પુનરાવર્તિત 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
```

## વેપાર-અક્ષોઃ અને ચેતવણીઓ

- **કેશ કી સ્ટ્રેટેજી**: `JSON.stringify` ફંક્શન્સ માટે અસફળ થાય છે, અને કી ક્રમ ઑબ્જેક્ટ્સ માટે મહત્વપૂર્ણ છે. ઑબ્જેક્ટ દલીલો માટે, a `WeakMap` (સંદર્ભ દ્વારા કીજ્ઞાપિત) મેમરી લીક ટાળે છે.
- **અસીમ વૃદ્ધિ**: કેશ ક્યારેય સંકુચિત થતો નથી — લાંબી ચાલતી પ્રક્રિયાઓ માટે **LRU** કેશ વાપરો.
- માત્ર memoize જ્યારે પુનર્ગણતરી ખરેખર ખર્ચાળ હોય અને ઇનપુટ્સ પુનરાવર્તિત થાય.

## શા માટે તે મહત્વપૂર્ણ છે

Memoization સર્વત્ર છે: React's `useMemo`/`React.memo`, Reselect સિલેક્ટર્સ, ગતિશીલ પ્રોગ્રામીંગ.

કલ્પના (શુદ્ધ પરિણામોને ઇનપુટ દ્વારા કેશ કરો) એક જ છે; કલા કી પસંદ કરવી અને કેશને બાંધવી છે.