જાવાસ્ક્રિપ્ટ મેમોઇઝેશન પેટર્ન્સ: કેશિંગ વ્યૂહરચનાઓ અને પર્ફોર્મન્સ લાભ

સોફ્ટવેર ડેવલપમેન્ટના ક્ષેત્રમાં, પર્ફોર્મન્સ સર્વોપરી છે. જાવાસ્ક્રિપ્ટ, ફ્રન્ટ-એન્ડ વેબ ડેવલપમેન્ટથી લઈને Node.js સાથે સર્વર-સાઇડ એપ્લિકેશન્સ સુધીના વિવિધ વાતાવરણમાં વપરાતી એક બહુમુખી ભાષા હોવાથી, સરળ અને કાર્યક્ષમ અમલ સુનિશ્ચિત કરવા માટે ઘણીવાર ઓપ્ટિમાઇઝેશનની જરૂર પડે છે. એક શક્તિશાળી તકનીક જે ચોક્કસ પરિસ્થિતિઓમાં પર્ફોર્મન્સમાં નોંધપાત્ર સુધારો કરી શકે છે તે છે મેમોઇઝેશન.

મેમોઇઝેશન એ એક ઓપ્ટિમાઇઝેશન તકનીક છે જેનો ઉપયોગ મુખ્યત્વે મોંઘા ફંક્શન કોલ્સના પરિણામોને સંગ્રહિત કરીને અને જ્યારે સમાન ઇનપુટ્સ ફરીથી આવે ત્યારે કેશ્ડ પરિણામ પરત કરીને કમ્પ્યુટર પ્રોગ્રામ્સને ઝડપી બનાવવા માટે થાય છે. સારમાં, તે કેશિંગનું એક સ્વરૂપ છે જે ખાસ કરીને ફંક્શન્સને લક્ષ્ય બનાવે છે. આ અભિગમ ખાસ કરીને એવા ફંક્શન્સ માટે અસરકારક છે જે:

• શુદ્ધ (Pure): એવા ફંક્શન્સ જેનું રિટર્ન મૂલ્ય ફક્ત તેમના ઇનપુટ મૂલ્યો દ્વારા નક્કી થાય છે, જેમાં કોઈ સાઇડ ઇફેક્ટ્સ ન હોય.
• નિર્ધારિત (Deterministic): સમાન ઇનપુટ માટે, ફંક્શન હંમેશા સમાન આઉટપુટ ઉત્પન્ન કરે છે.
• ખર્ચાળ (Expensive): એવા ફંક્શન્સ જેની ગણતરીઓ કોમ્પ્યુટેશનલ રીતે સઘન અથવા સમય માંગી લેતી હોય (દા.ત., રિકર્સિવ ફંક્શન્સ, જટિલ ગણતરીઓ).

આ લેખ જાવાસ્ક્રિપ્ટમાં મેમોઇઝેશનના ખ્યાલનું અન્વેષણ કરે છે, જેમાં તેના અમલીકરણ દ્વારા પ્રાપ્ત કરી શકાય તેવા વિવિધ પેટર્ન્સ, કેશિંગ વ્યૂહરચનાઓ અને પર્ફોર્મન્સ લાભો વિશે ઊંડાણપૂર્વક ચર્ચા કરવામાં આવી છે. અમે જુદા જુદા સંજોગોમાં મેમોઇઝેશનને અસરકારક રીતે કેવી રીતે લાગુ કરવું તે દર્શાવવા માટે વ્યવહારુ ઉદાહરણોની તપાસ કરીશું.

મેમોઇઝેશનને સમજવું: મુખ્ય ખ્યાલ

તેના મૂળમાં, મેમોઇઝેશન કેશિંગના સિદ્ધાંતનો લાભ ઉઠાવે છે. જ્યારે કોઈ મેમોઇઝ્ડ ફંક્શનને ચોક્કસ આર્ગ્યુમેન્ટ્સના સેટ સાથે કોલ કરવામાં આવે છે, ત્યારે તે સૌ પ્રથમ તપાસે છે કે તે આર્ગ્યુમેન્ટ્સ માટેનું પરિણામ પહેલેથી જ ગણતરી કરીને કેશમાં (સામાન્ય રીતે જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ અથવા Map) સંગ્રહિત છે કે નહીં. જો પરિણામ કેશમાં મળે છે, તો તે તરત જ પરત કરવામાં આવે છે. નહિંતર, ફંક્શન ગણતરી કરે છે, પરિણામને કેશમાં સંગ્રહિત કરે છે, અને પછી તેને પરત કરે છે.

મુખ્ય ફાયદો બિનજરૂરી ગણતરીઓ ટાળવામાં રહેલો છે. જો કોઈ ફંક્શનને સમાન ઇનપુટ્સ સાથે ઘણી વખત કોલ કરવામાં આવે, તો મેમોઇઝ્ડ વર્ઝન ફક્ત એક જ વાર ગણતરી કરે છે. પછીના કોલ્સ સીધા કેશમાંથી પરિણામ મેળવે છે, જેના પરિણામે ખાસ કરીને કોમ્પ્યુટેશનલ રીતે ખર્ચાળ કામગીરી માટે પર્ફોર્મન્સમાં નોંધપાત્ર સુધારો થાય છે.

જાવાસ્ક્રિપ્ટમાં મેમોઇઝેશન પેટર્ન્સ

જાવાસ્ક્રિપ્ટમાં મેમોઇઝેશન લાગુ કરવા માટે અનેક પેટર્ન્સનો ઉપયોગ કરી શકાય છે. ચાલો આપણે કેટલાક સૌથી સામાન્ય અને અસરકારક પેટર્ન્સની તપાસ કરીએ:

1. ક્લોઝર સાથે બેઝિક મેમોઇઝેશન

મેમોઇઝેશન માટે આ સૌથી મૂળભૂત અભિગમ છે. તે ફંક્શનના સ્કોપમાં કેશ જાળવવા માટે ક્લોઝરનો ઉપયોગ કરે છે. કેશ સામાન્ય રીતે એક સરળ જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ હોય છે જ્યાં કી ફંક્શન આર્ગ્યુમેન્ટ્સનું પ્રતિનિધિત્વ કરે છે અને વેલ્યુ અનુરૂપ પરિણામોનું પ્રતિનિધિત્વ કરે છે.

function memoize(func) {
 const cache = {};
 return function(...args) {
 const key = JSON.stringify(args); // Create a unique key for the arguments
 if (cache[key]) {
 return cache[key]; // Return cached result
 } else {
 const result = func.apply(this, args); // Calculate the result
 cache[key] = result; // Store the result in the cache
 return result; // Return the result
 }
 };
}

// Example: Memoizing a factorial function
function factorial(n) {
 if (n <= 1) {
 return 1;
 }
 return n * factorial(n - 1);
}

const memoizedFactorial = memoize(factorial);

console.time('First call');
console.log(memoizedFactorial(5)); // Calculates and caches
console.timeEnd('First call');

console.time('Second call');
console.log(memoizedFactorial(5)); // Retrieves from cache
console.timeEnd('Second call');

સમજૂતી:

• `memoize` ફંક્શન ઇનપુટ તરીકે `func` ફંક્શન લે છે.
• તે તેના સ્કોપમાં (ક્લોઝરનો ઉપયોગ કરીને) `cache` ઓબ્જેક્ટ બનાવે છે.
• તે એક નવું ફંક્શન પરત કરે છે જે મૂળ ફંક્શનને રેપ કરે છે.
• આ રેપર ફંક્શન `JSON.stringify(args)` નો ઉપયોગ કરીને ફંક્શન આર્ગ્યુમેન્ટ્સના આધારે એક અનન્ય કી બનાવે છે.
• તે તપાસે છે કે `key` `cache` માં અસ્તિત્વમાં છે કે નહીં. જો હોય, તો તે કેશ્ડ વેલ્યુ પરત કરે છે.
• જો `key` અસ્તિત્વમાં ન હોય, તો તે મૂળ ફંક્શનને કોલ કરે છે, પરિણામને `cache` માં સંગ્રહિત કરે છે, અને પરિણામ પરત કરે છે.

મર્યાદાઓ:

• જટિલ ઓબ્જેક્ટ્સ માટે `JSON.stringify` ધીમું હોઈ શકે છે.
• કી બનાવવાની પ્રક્રિયા એવા ફંક્શન્સ સાથે સમસ્યારૂપ બની શકે છે કે જે અલગ-અલગ ક્રમમાં આર્ગ્યુમેન્ટ્સ સ્વીકારે છે અથવા જે સમાન કી પરંતુ અલગ ક્રમ ધરાવતા ઓબ્જેક્ટ્સ હોય.
• `NaN` ને યોગ્ય રીતે હેન્ડલ કરતું નથી કારણ કે `JSON.stringify(NaN)` `null` પરત કરે છે.

2. કસ્ટમ કી જનરેટર સાથે મેમોઇઝેશન

`JSON.stringify` ની મર્યાદાઓને દૂર કરવા માટે, તમે એક કસ્ટમ કી જનરેટર ફંક્શન બનાવી શકો છો જે ફંક્શનના આર્ગ્યુમેન્ટ્સના આધારે એક અનન્ય કી ઉત્પન્ન કરે છે. આ કેશને કેવી રીતે ઇન્ડેક્સ કરવામાં આવે છે તેના પર વધુ નિયંત્રણ પૂરું પાડે છે અને અમુક પરિસ્થિતિઓમાં પર્ફોર્મન્સ સુધારી શકે છે.

function memoizeWithKey(func, keyGenerator) {
 const cache = {};
 return function(...args) {
 const key = keyGenerator(...args);
 if (cache[key]) {
 return cache[key];
 } else {
 const result = func.apply(this, args);
 cache[key] = result;
 return result;
 }
 };
}

// Example: Memoizing a function that adds two numbers
function add(a, b) {
 console.log('Calculating...');
 return a + b;
}

// Custom key generator for the add function
function addKeyGenerator(a, b) {
 return `${a}-${b}`;
}

const memoizedAdd = memoizeWithKey(add, addKeyGenerator);

console.log(memoizedAdd(2, 3)); // Calculates and caches
console.log(memoizedAdd(2, 3)); // Retrieves from cache
console.log(memoizedAdd(3, 2)); // Calculates and caches (different key)

સમજૂતી:

• આ પેટર્ન બેઝિક મેમોઇઝેશન જેવી જ છે, પરંતુ તે એક વધારાનું આર્ગ્યુમેન્ટ સ્વીકારે છે: `keyGenerator`.
• `keyGenerator` એ એક ફંક્શન છે જે મૂળ ફંક્શન જેવા જ આર્ગ્યુમેન્ટ્સ લે છે અને એક અનન્ય કી પરત કરે છે.
• આ વધુ લવચીક અને કાર્યક્ષમ કી બનાવવાની મંજૂરી આપે છે, ખાસ કરીને એવા ફંક્શન્સ માટે કે જે જટિલ ડેટા સ્ટ્રક્ચર્સ સાથે કામ કરે છે.

3. Map સાથે મેમોઇઝેશન

જાવાસ્ક્રિપ્ટમાં `Map` ઓબ્જેક્ટ કેશ્ડ પરિણામોને સંગ્રહિત કરવાની વધુ મજબૂત અને બહુમુખી રીત પ્રદાન કરે છે. સાદા જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ્સથી વિપરીત, `Map` તમને ઓબ્જેક્ટ્સ અને ફંક્શન્સ સહિત કોઈપણ ડેટા પ્રકારને કી તરીકે ઉપયોગ કરવાની મંજૂરી આપે છે. આ આર્ગ્યુમેન્ટ્સને સ્ટ્રિંગિફાય કરવાની જરૂરિયાતને દૂર કરે છે અને કી બનાવવાનું સરળ બનાવે છે.

function memoizeWithMap(func) {
 const cache = new Map();
 return function(...args) {
 const key = args.join('|'); // Create a simple key (can be more sophisticated)
 if (cache.has(key)) {
 return cache.get(key);
 } else {
 const result = func.apply(this, args);
 cache.set(key, result);
 return result;
 }
 };
}

// Example: Memoizing a function that concatenates strings
function concatenate(str1, str2) {
 console.log('Concatenating...');
 return str1 + str2;
}

const memoizedConcatenate = memoizeWithMap(concatenate);

console.log(memoizedConcatenate('hello', 'world')); // Calculates and caches
console.log(memoizedConcatenate('hello', 'world')); // Retrieves from cache

સમજૂતી:

• આ પેટર્ન કેશ સંગ્રહિત કરવા માટે `Map` ઓબ્જેક્ટનો ઉપયોગ કરે છે.
• `Map` તમને ઓબ્જેક્ટ્સ અને ફંક્શન્સ સહિત કોઈપણ ડેટા પ્રકારને કી તરીકે ઉપયોગ કરવાની મંજૂરી આપે છે, જે સાદા જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ્સની તુલનામાં વધુ લવચીકતા પૂરી પાડે છે.
• `Map` ઓબ્જેક્ટની `has` અને `get` પદ્ધતિઓનો ઉપયોગ અનુક્રમે કેશ્ડ વેલ્યુઝ તપાસવા અને મેળવવા માટે થાય છે.

4. રિકર્સિવ મેમોઇઝેશન

મેમોઇઝેશન રિકર્સિવ ફંક્શન્સને ઓપ્ટિમાઇઝ કરવા માટે ખાસ કરીને અસરકારક છે. મધ્યવર્તી ગણતરીઓના પરિણામોને કેશ કરીને, તમે બિનજરૂરી ગણતરીઓ ટાળી શકો છો અને અમલના સમયમાં નોંધપાત્ર ઘટાડો કરી શકો છો.

function memoizeRecursive(func) {
 const cache = {};
 function memoized(...args) {
 const key = String(args);
 if (cache[key]) {
 return cache[key];
 } else {
 cache[key] = func(memoized, ...args);
 return cache[key];
 }
 }
 return memoized;
}

// Example: Memoizing a Fibonacci sequence function
function fibonacci(memoized, n) {
 if (n <= 1) {
 return n;
 }
 return memoized(n - 1) + memoized(n - 2);
}

const memoizedFibonacci = memoizeRecursive(fibonacci);

console.time('First call');
console.log(memoizedFibonacci(10)); // Calculates and caches
console.timeEnd('First call');

console.time('Second call');
console.log(memoizedFibonacci(10)); // Retrieves from cache
console.timeEnd('Second call');

સમજૂતી:

• `memoizeRecursive` ફંક્શન ઇનપુટ તરીકે `func` ફંક્શન લે છે.
• તે તેના સ્કોપમાં `cache` ઓબ્જેક્ટ બનાવે છે.
• તે એક નવું ફંક્શન `memoized` પરત કરે છે જે મૂળ ફંક્શનને રેપ કરે છે.
• `memoized` ફંક્શન તપાસે છે કે આપેલ આર્ગ્યુમેન્ટ્સ માટેનું પરિણામ પહેલેથી જ કેશમાં છે કે નહીં. જો હોય, તો તે કેશ્ડ વેલ્યુ પરત કરે છે.
• જો પરિણામ કેશમાં ન હોય, તો તે `memoized` ફંક્શનને જ પ્રથમ આર્ગ્યુમેન્ટ તરીકે મૂળ ફંક્શનને કોલ કરે છે. આ મૂળ ફંક્શનને પોતાની મેમોઇઝ્ડ વર્ઝનને રિકર્સિવલી કોલ કરવાની મંજૂરી આપે છે.
• પરિણામ પછી કેશમાં સંગ્રહિત થાય છે અને પરત કરવામાં આવે છે.

5. ક્લાસ-આધારિત મેમોઇઝેશન

ઓબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ માટે, મેથડ્સના પરિણામોને કેશ કરવા માટે ક્લાસની અંદર મેમોઇઝેશન લાગુ કરી શકાય છે. આ કોમ્પ્યુટેશનલ રીતે ખર્ચાળ મેથડ્સ માટે ઉપયોગી થઈ શકે છે જે સમાન આર્ગ્યુમેન્ટ્સ સાથે વારંવાર કોલ કરવામાં આવે છે.

class MemoizedClass {
 constructor() {
 this.cache = {};
 }

 memoizeMethod(func) {
 return (...args) => {
 const key = JSON.stringify(args);
 if (this.cache[key]) {
 return this.cache[key];
 } else {
 const result = func.apply(this, args);
 this.cache[key] = result;
 return result;
 }
 };
 }

 // Example: Memoizing a method that calculates the power of a number
 power(base, exponent) {
 console.log('Calculating power...');
 return Math.pow(base, exponent);
 }
}

const memoizedInstance = new MemoizedClass();
const memoizedPower = memoizedInstance.memoizeMethod(memoizedInstance.power);

console.log(memoizedPower(2, 3)); // Calculates and caches
console.log(memoizedPower(2, 3)); // Retrieves from cache

સમજૂતી:

• `MemoizedClass` તેના કન્સ્ટ્રક્ટરમાં `cache` પ્રોપર્ટી વ્યાખ્યાયિત કરે છે.
• `memoizeMethod` ઇનપુટ તરીકે એક ફંક્શન લે છે અને તે ફંક્શનનું મેમોઇઝ્ડ વર્ઝન પરત કરે છે, જે પરિણામોને ક્લાસના `cache` માં સંગ્રહિત કરે છે.
• આ તમને ક્લાસની ચોક્કસ મેથડ્સને પસંદગીપૂર્વક મેમોઇઝ કરવાની મંજૂરી આપે છે.

કેશિંગ વ્યૂહરચનાઓ

બેઝિક મેમોઇઝેશન પેટર્ન્સ ઉપરાંત, કેશના વર્તનને ઓપ્ટિમાઇઝ કરવા અને તેનું કદ સંચાલિત કરવા માટે વિવિધ કેશિંગ વ્યૂહરચનાઓનો ઉપયોગ કરી શકાય છે. આ વ્યૂહરચનાઓ સુનિશ્ચિત કરવામાં મદદ કરે છે કે કેશ કાર્યક્ષમ રહે અને વધુ પડતી મેમરીનો વપરાશ ન કરે.

1. લીસ્ટ રિસન્ટલી યુઝ્ડ (LRU) કેશ

જ્યારે કેશ તેની મહત્તમ સાઈઝ પર પહોંચે છે ત્યારે LRU કેશ સૌથી ઓછી તાજેતરમાં વપરાયેલી આઇટમ્સને દૂર કરે છે. આ વ્યૂહરચના સુનિશ્ચિત કરે છે કે સૌથી વધુ વારંવાર એક્સેસ થતો ડેટા કેશમાં રહે, જ્યારે ઓછો વારંવાર વપરાતો ડેટા કાઢી નાખવામાં આવે છે.

class LRUCache {
 constructor(capacity) {
 this.capacity = capacity;
 this.cache = new Map();
 }

 get(key) {
 if (this.cache.has(key)) {
 const value = this.cache.get(key);
 this.cache.delete(key); // Re-insert to mark as recently used
 this.cache.set(key, value);
 return value;
 } else {
 return undefined;
 }
 }

 put(key, value) {
 if (this.cache.has(key)) {
 this.cache.delete(key);
 }
 this.cache.set(key, value);
 if (this.cache.size > this.capacity) {
 // Remove the least recently used item
 const firstKey = this.cache.keys().next().value;
 this.cache.delete(firstKey);
 }
 }
}

// Example usage:
const lruCache = new LRUCache(3); // Capacity of 3

lruCache.put('a', 1);
lruCache.put('b', 2);
lruCache.put('c', 3);

console.log(lruCache.get('a')); // 1 (moves 'a' to the end)

lruCache.put('d', 4); // 'b' is evicted

console.log(lruCache.get('b')); // undefined
console.log(lruCache.get('a')); // 1
console.log(lruCache.get('c')); // 3
console.log(lruCache.get('d')); // 4

સમજૂતી:

• કેશ સંગ્રહિત કરવા માટે `Map` નો ઉપયોગ કરે છે, જે ઇન્સર્શન ઓર્ડર જાળવી રાખે છે.
• `get(key)` વેલ્યુ મેળવે છે અને કી-વેલ્યુ જોડીને ફરીથી દાખલ કરે છે જેથી તેને તાજેતરમાં વપરાયેલી તરીકે ચિહ્નિત કરી શકાય.
• `put(key, value)` કી-વેલ્યુ જોડી દાખલ કરે છે. જો કેશ ભરાઈ ગયો હોય, તો સૌથી ઓછી તાજેતરમાં વપરાયેલી આઇટમ (`Map` માં પ્રથમ આઇટમ) દૂર કરવામાં આવે છે.

2. લીસ્ટ ફ્રિક્વન્ટલી યુઝ્ડ (LFU) કેશ

જ્યારે કેશ ભરાઈ જાય ત્યારે LFU કેશ સૌથી ઓછી વારંવાર વપરાયેલી આઇટમ્સને દૂર કરે છે. આ વ્યૂહરચના એવા ડેટાને પ્રાથમિકતા આપે છે જે વધુ વખત એક્સેસ થાય છે, જેથી તે કેશમાં રહે તે સુનિશ્ચિત થાય છે.

class LFUCache {
 constructor(capacity) {
 this.capacity = capacity;
 this.cache = new Map();
 this.frequencies = new Map();
 this.minFrequency = 0;
 }

 get(key) {
 if (!this.cache.has(key)) {
 return undefined;
 }

 const frequency = this.frequencies.get(key);
 this.frequencies.set(key, frequency + 1);
 return this.cache.get(key);
 }

 put(key, value) {
 if (this.capacity <= 0) {
 return;
 }

 if (this.cache.has(key)) {
 this.cache.set(key, value);
 this.get(key);
 return;
 }

 if (this.cache.size >= this.capacity) {
 this.evict();
 }

 this.cache.set(key, value);
 this.frequencies.set(key, 1);
 this.minFrequency = 1;
 }

 evict() {
 let minFreq = Infinity;
 for (const frequency of this.frequencies.values()) {
 minFreq = Math.min(minFreq, frequency);
 }

 const keysToRemove = [];
 this.frequencies.forEach((freq, key) => {
 if (freq === minFreq) {
 keysToRemove.push(key);
 }
 });

 const keyToRemove = keysToRemove[0];
 this.cache.delete(keyToRemove);
 this.frequencies.delete(keyToRemove);
 }
}

// Example usage:
const lfuCache = new LFUCache(2);

lfuCache.put('a', 1);
lfuCache.put('b', 2);
console.log(lfuCache.get('a')); // 1, frequency(a) = 2
lfuCache.put('c', 3); // evicts 'b' because frequency(b) = 1
console.log(lfuCache.get('b')); // undefined
console.log(lfuCache.get('a')); // 1, frequency(a) = 3
console.log(lfuCache.get('c')); // 3, frequency(c) = 2

સમજૂતી:

• બે `Map` ઓબ્જેક્ટ્સનો ઉપયોગ કરે છે: કી-વેલ્યુ જોડી સંગ્રહિત કરવા માટે `cache` અને દરેક કીની એક્સેસ ફ્રિક્વન્સી સંગ્રહિત કરવા માટે `frequencies`.
• `get(key)` વેલ્યુ મેળવે છે અને ફ્રિક્વન્સી કાઉન્ટમાં વધારો કરે છે.
• `put(key, value)` કી-વેલ્યુ જોડી દાખલ કરે છે. જો કેશ ભરાઈ ગયો હોય, તો તે સૌથી ઓછી વારંવાર વપરાયેલી આઇટમને દૂર કરે છે.
• `evict()` ન્યૂનતમ ફ્રિક્વન્સી કાઉન્ટ શોધે છે અને `cache` અને `frequencies` બંનેમાંથી સંબંધિત કી-વેલ્યુ જોડીને દૂર કરે છે.

3. સમય-આધારિત એક્સપાયરેશન

આ વ્યૂહરચના ચોક્કસ સમયગાળા પછી કેશ્ડ આઇટમ્સને અમાન્ય બનાવે છે. આ એવા ડેટા માટે ઉપયોગી છે જે સમય જતાં વાસી અથવા જૂનો થઈ જાય છે. ઉદાહરણ તરીકે, API રિસ્પોન્સને કેશ કરવું જે ફક્ત થોડી મિનિટો માટે જ માન્ય હોય છે.

function memoizeWithExpiration(func, ttl) {
 const cache = new Map();
 return function(...args) {
 const key = JSON.stringify(args);
 const cached = cache.get(key);

 if (cached && cached.expiry > Date.now()) {
 return cached.value;
 } else {
 const result = func.apply(this, args);
 cache.set(key, { value: result, expiry: Date.now() + ttl });
 return result;
 }
 };
}

// Example: Memoizing a function with a 5-second expiration time
function getDataFromAPI(endpoint) {
 console.log(`Fetching data from ${endpoint}...`);
 // Simulate an API call with a delay
 return new Promise(resolve => {
 setTimeout(() => {
 resolve(`Data from ${endpoint}`);
 }, 1000);
 });
}

const memoizedGetData = memoizeWithExpiration(getDataFromAPI, 5000); // TTL: 5 seconds

async function testExpiration() {
 console.log(await memoizedGetData('/users')); // Fetches and caches
 console.log(await memoizedGetData('/users')); // Retrieves from cache

 setTimeout(async () => {
 console.log(await memoizedGetData('/users')); // Fetches again after 5 seconds
 }, 6000);
}

testExpiration();

સમજૂતી:

• `memoizeWithExpiration` ફંક્શન ઇનપુટ તરીકે `func` ફંક્શન અને મિલિસેકન્ડમાં ટાઈમ-ટુ-લિવ (TTL) વેલ્યુ લે છે.
• તે કેશ્ડ વેલ્યુને એક્સપાયરી ટાઇમસ્ટેમ્પ સાથે સંગ્રહિત કરે છે.
• કેશ્ડ વેલ્યુ પરત કરતાં પહેલાં, તે તપાસે છે કે એક્સપાયરી ટાઇમસ્ટેમ્પ હજી ભવિષ્યમાં છે કે નહીં. જો નહીં, તો તે કેશને અમાન્ય બનાવે છે અને ડેટા ફરીથી મેળવે છે.

પર્ફોર્મન્સ લાભ અને વિચારણાઓ

મેમોઇઝેશન પર્ફોર્મન્સમાં નોંધપાત્ર સુધારો કરી શકે છે, ખાસ કરીને કોમ્પ્યુટેશનલ રીતે ખર્ચાળ ફંક્શન્સ માટે કે જે સમાન ઇનપુટ્સ સાથે વારંવાર કોલ કરવામાં આવે છે. પર્ફોર્મન્સ લાભ નીચેના સંજોગોમાં સૌથી વધુ સ્પષ્ટ છે:

• રિકર્સિવ ફંક્શન્સ: મેમોઇઝેશન રિકર્સિવ કોલ્સની સંખ્યામાં નાટકીય રીતે ઘટાડો કરી શકે છે, જેનાથી ઘાતાંકીય પર્ફોર્મન્સ સુધારા થાય છે.
• ઓવરલેપિંગ સબપ્રોબ્લેમ્સવાળા ફંક્શન્સ: મેમોઇઝેશન સબપ્રોબ્લેમ્સના પરિણામોને સંગ્રહિત કરીને અને જરૂર પડ્યે તેનો પુનઃઉપયોગ કરીને બિનજરૂરી ગણતરીઓ ટાળી શકે છે.
• વારંવાર સમાન ઇનપુટ્સવાળા ફંક્શન્સ: મેમોઇઝેશન સુનિશ્ચિત કરે છે કે ફંક્શન ફક્ત દરેક અનન્ય ઇનપુટ્સના સેટ માટે એક જ વાર એક્ઝિક્યુટ થાય છે.

જોકે, મેમોઇઝેશનનો ઉપયોગ કરતી વખતે નીચેના ટ્રેડ-ઓફ્સને ધ્યાનમાં લેવું મહત્વપૂર્ણ છે:

• મેમરી વપરાશ: મેમોઇઝેશન મેમરીનો ઉપયોગ વધારે છે કારણ કે તે ફંક્શન કોલ્સના પરિણામોને સંગ્રહિત કરે છે. મોટી સંખ્યામાં સંભવિત ઇનપુટ્સવાળા ફંક્શન્સ માટે અથવા મર્યાદિત મેમરી સંસાધનોવાળી એપ્લિકેશન્સ માટે આ ચિંતાનો વિષય બની શકે છે.
• કેશ અમાન્યતા: જો અંતર્ગત ડેટા બદલાય છે, તો કેશ્ડ પરિણામો વાસી થઈ શકે છે. કેશ ડેટા સાથે સુસંગત રહે તે સુનિશ્ચિત કરવા માટે કેશ અમાન્યતા વ્યૂહરચના લાગુ કરવી નિર્ણાયક છે.
• જટિલતા: મેમોઇઝેશન લાગુ કરવાથી કોડમાં જટિલતા વધી શકે છે, ખાસ કરીને જટિલ કેશિંગ વ્યૂહરચનાઓ માટે. મેમોઇઝેશનનો ઉપયોગ કરતાં પહેલાં કોડની જટિલતા અને જાળવણીક્ષમતાને કાળજીપૂર્વક ધ્યાનમાં લેવી મહત્વપૂર્ણ છે.

વ્યવહારુ ઉદાહરણો અને ઉપયોગના કેસો

મેમોઇઝેશનને પર્ફોર્મન્સ ઓપ્ટિમાઇઝ કરવા માટે વિશાળ શ્રેણીના સંજોગોમાં લાગુ કરી શકાય છે. અહીં કેટલાક વ્યવહારુ ઉદાહરણો છે:

• ફ્રન્ટ-એન્ડ વેબ ડેવલપમેન્ટ: જાવાસ્ક્રિપ્ટમાં ખર્ચાળ ગણતરીઓને મેમોઇઝ કરવાથી વેબ એપ્લિકેશન્સની રિસ્પોન્સિવનેસ સુધરી શકે છે. ઉદાહરણ તરીકે, તમે એવા ફંક્શન્સને મેમોઇઝ કરી શકો છો જે જટિલ DOM મેનિપ્યુલેશન્સ કરે છે અથવા લેઆઉટ પ્રોપર્ટીઝની ગણતરી કરે છે.
• સર્વર-સાઇડ એપ્લિકેશન્સ: મેમોઇઝેશનનો ઉપયોગ ડેટાબેઝ ક્વેરીઝ અથવા API કોલ્સના પરિણામોને કેશ કરવા માટે કરી શકાય છે, જેનાથી સર્વર પરનો ભાર ઘટે છે અને રિસ્પોન્સ સમય સુધરે છે.
• ડેટા એનાલિસિસ: મેમોઇઝેશન મધ્યવર્તી ગણતરીઓના પરિણામોને કેશ કરીને ડેટા એનાલિસિસ કાર્યોને ઝડપી બનાવી શકે છે. ઉદાહરણ તરીકે, તમે એવા ફંક્શન્સને મેમોઇઝ કરી શકો છો જે સ્ટેટિસ્ટિકલ એનાલિસિસ અથવા મશીન લર્નિંગ એલ્ગોરિધમ્સ કરે છે.
• ગેમ ડેવલપમેન્ટ: મેમોઇઝેશનનો ઉપયોગ વારંવાર વપરાતી ગણતરીઓના પરિણામોને કેશ કરીને ગેમ પર્ફોર્મન્સને ઓપ્ટિમાઇઝ કરવા માટે કરી શકાય છે, જેમ કે કોલિઝન ડિટેક્શન અથવા પાથફાઇન્ડિંગ.

નિષ્કર્ષ

મેમોઇઝેશન એક શક્તિશાળી ઓપ્ટિમાઇઝેશન તકનીક છે જે જાવાસ્ક્રિપ્ટ એપ્લિકેશન્સના પર્ફોર્મન્સમાં નોંધપાત્ર સુધારો કરી શકે છે. ખર્ચાળ ફંક્શન કોલ્સના પરિણામોને કેશ કરીને, તમે બિનજરૂરી ગણતરીઓ ટાળી શકો છો અને એક્ઝિક્યુશન સમય ઘટાડી શકો છો. જોકે, પર્ફોર્મન્સ લાભ અને મેમરી વપરાશ, કેશ અમાન્યતા અને કોડ જટિલતા વચ્ચેના ટ્રેડ-ઓફ્સને કાળજીપૂર્વક ધ્યાનમાં લેવું મહત્વપૂર્ણ છે. વિવિધ મેમોઇઝેશન પેટર્ન્સ અને કેશિંગ વ્યૂહરચનાઓને સમજીને, તમે તમારા જાવાસ્ક્રિપ્ટ કોડને ઓપ્ટિમાઇઝ કરવા અને ઉચ્ચ-પર્ફોર્મન્સ એપ્લિકેશન્સ બનાવવા માટે મેમોઇઝેશનને અસરકારક રીતે લાગુ કરી શકો છો.