memoization ਕੀ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

**Memoization** ਇੱਕ ਫੰਕਸ਼ਨ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਇਸ ਦੀਆਂ arguments ਨਾਲ keyed ਕਰਕੇ cache ਕਰਦਾ ਹੈ, ਇਸਲਈ ਉਹੀ inputs ਦੇ ਨਾਲ ਦੁਹਰਾਈ ਕਾਲ ਤੁਰੰਤ cached ਨਤੀਜਾ ਵਾਪਸ ਕਰਦੀ ਹੈ ਬਜਾਏ ਮੁੜ ਗਣਨਾ ਕਰਨ ਦੇ। ਇਹ **memory ਨੂੰ speed ਲਈ ਬਦਲਦਾ ਹੈ** ਅਤੇ ਸਿਰਫ **pure** ਫੰਕਸ਼ਨਾਂ ਲਈ ਕਾਮ ਕਰਦਾ ਹੈ (ਉਹੀ input → ਉਹੀ output, ਕੋਈ side effects ਨਹੀਂ)।

## ਇੱਕ generic 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
```

## ਇੱਕ classic win: 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 ਅਤੇ caveats

- **Cache key strategy**: `JSON.stringify` functions ਲਈ ਫੇਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ key order objects ਲਈ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ। Object arguments ਲਈ, ਇੱਕ `WeakMap` (reference ਦੁਆਰਾ keyed) memory leaks ਤੋਂ ਬਚਦਾ ਹੈ।
- **Unbounded growth**: cache ਕਦੇ ਛੋਟਾ ਨਹੀਂ ਹੁੰਦਾ — long-running processes ਲਈ ਇੱਕ **LRU** cache ਵਰਤੋ।
- ਸਿਰਫ memoize ਕਰੋ ਜਦੋਂ recomputation ਸਚਮੁੱਚ ਮਹਿੰਗਾ ਹੋ ਅਤੇ inputs ਦੁਹਰਾਏ ਜਾਣ।

## ਇਸ ਨੂੰ ਮਾਇਨੇ ਕਿਉਂ ਹੈ

Memoization ਹਰ ਜਗ੍ਹਾ ਹੈ: React ਦੇ `useMemo`/`React.memo`, Reselect selectors, dynamic programming।

The concept (cache pure results by input) ਉਹੀ ਹੈ; the art ਹੈ key ਨੂੰ ਚੁਣਨਾ ਅਤੇ cache ਨੂੰ bound ਕਰਨਾ।