Memoization என்றால் என்ன, அதை எவ்வாறு செயல்படுத்துவீர்கள்?

Question

Accepted Answer

**Memoization** ஒரு function-இன் முடிவுகளை அதன் arguments-ஐ key ஆகக் கொண்டு cache செய்கிறது, இதனால் ஒரே inputs-உடன் மீண்டும் மீண்டும் வரும் calls மறு கணக்கீடு செய்யாமல் cache செய்யப்பட்ட முடிவை உடனடியாகத் திருப்பித் தருகின்றன. இது **வேகத்திற்காக memory-ஐ** பரிமாறுகிறது மற்றும் **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
```

## ஒரு classic வெற்றி: 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-ஐ தவிர்க்கிறது.
- **வரம்பற்ற வளர்ச்சி**: cache ஒருபோதும் சுருங்காது — நீண்ட நேரம் இயங்கும் processes-க்கு ஒரு **LRU** cache-ஐ பயன்படுத்தவும்.
- மறு கணக்கீடு உண்மையில் விலையுயர்ந்ததாகவும் inputs மீண்டும் வரும்போதும் மட்டுமே memoize செய்யவும்.

## இது ஏன் முக்கியம்

Memoization எல்லா இடங்களிலும் உள்ளது: React-இன் `useMemo`/`React.memo`, Reselect selectors, dynamic programming.

கருத்து (input ஆல் pure முடிவுகளை cache செய்வது) ஒன்றே; கலை என்பது key-ஐ தேர்ந்தெடுப்பதும் cache-ஐ வரம்பிடுவதும் ஆகும்.