तो मैंने संस्मरण की इस दिलचस्प छोटी अवधारणा की खोज की है।

मैंने इसके बारे में लेख पढ़ना शुरू कर दिया है और जैसे ही मुझे विचार का पता चला, मैं रुक गया।

फिर मैंने अपने तरीके से और जिस तरह से मैं इसे समझता हूं, उस सरल समाधान को निकालने का फैसला किया।

यदि आपने इसके बारे में कभी नहीं सुना है, तो मेमोइज़ेशन फ़ंक्शन निष्पादन के परिणामों को संग्रहीत करने की प्रक्रिया है, इसलिए अगली बार जब आप उसी तर्क के साथ उस फ़ंक्शन को चलाते हैं तो आप इसे थोड़े (या नहीं) कैश से खींच सकते हैं।

वास्तव में यह उच्च संसाधन खपत वाले कार्य के लिए उपयोगी हो सकता है। यह कैश के रूप में अतिरिक्त स्थान का उपयोग करने की लागत के साथ आता है। लेकिन यह आपके कोड की गति और इसका उपयोग करने वाले उपयोगकर्ताओं के अनुभव में सुधार कर सकता है।

मैंने जेएस कोड के साथ थोड़ा खेला है और इस समाधान के साथ आया हूं:

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
    if(!cache[fnKey]) {
      cache[fnKey] = fn(...args);
    }

    return cache[fnKey]
  };
}

फिर आप इसे इस तरह चला सकते हैं:

function _add(x, y) {
  console.log("function runs", x, y);
  return x   y;
}

const add = memoize(_add)

add(42, 69)
add(10, 15)
add(10, 15)

इससे फ़ंक्शन दो बार निष्पादित होता है (#1 ​​और #2 'ऐड' कॉल)। तीसरी 'ऐड' कॉल कैश का उपयोग करेगी क्योंकि यह #2 कॉल के समान है।

'function runs' 42 69
'function runs' 10 15

आप देख सकते हैं कि 'फ़ंक्शन रन' 10 15 को केवल एक बार कॉल किया जाता है। ऐसा इसलिए है क्योंकि दूसरी बार जब हम इसे कॉल करते हैं, तो कैश का उपयोग किया जा रहा होता है।

अब यहां जो कुछ हो रहा है उसका शीघ्रता से विश्लेषण करें।

इस उदाहरण में हम कैश को स्टोर करने के लिए क्लोजर मैकेनिज्म का उपयोग करते हैं।

const memoize = fn => {
  const cache = {}
  return () => {

  };
}

यह हमें "एफएन" तर्क को फेंकने की अनुमति देता है, जो पार्टी का राजा है क्योंकि यह बिल्कुल वही फ़ंक्शन है जिसके साथ हम काम करना चाहते हैं, दायरे से नीचे और इसके प्रत्येक निष्पादन को "सुनना"।

मैंने इसे वास्तव में सबसे सरल, सरल तरीके से लिखा है। इसलिए हम कैश की कुंजी के रूप में तर्कों के साथ फ़ंक्शन नाम का उपयोग करने जा रहे हैं, और इसके निष्पादन के परिणामों को मान के रूप में उपयोग करने जा रहे हैं।

इसका मतलब है, कि निष्पादन:

add(2, 2)

का परिणाम

// Our cache
{
  'add(2, 2)': 4
}

कैश मान.

मुझे पता है कि यह संभवतः बिल्कुल वैसा नहीं है जैसा इसे "सही तरीके" से किया जाना चाहिए। लेकिन इस अभ्यास और लेख का विचार अच्छी तरह से परीक्षण किए गए सुरक्षित और एज केस मुक्त समाधान के बारे में नहीं है।

यह सीखने और सरल कार्यान्वयन के बारे में है। अवधारणा के बारे में. इसलिए मैं अभी कार्यान्वयन के विवरण पर ध्यान केंद्रित नहीं कर रहा हूं।

अब, हम पहले फ़ंक्शन कॉल के लिए कुंजी का पता लगाते हैं:

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
  };
}

हम इसका उपयोग कैश में फ़ंक्शन निष्पादन के परिणामों को संग्रहीत करने के लिए करेंगे।

फिर हम जांचते हैं कि क्या यह कुंजी (fnKey) पहले से मौजूद है। यदि नहीं, तो हम पारित फ़ंक्शन निष्पादन के परिणामस्वरूप कुंजी को उसके मान के साथ सेट करते हैं।

अंत में हम हमेशा कैश से परिणाम लौटाते हैं। तो वास्तव में मेमोइज़ विधि में पारित फ़ंक्शन का निष्पादन हमेशा क्लोजर ("कैश" ऑब्जेक्ट में) में समाप्त होता है।

अब हम केवल इस ऑब्जेक्ट के साथ काम करते हैं:

const memoize = fn => {
  const cache = {}
  return (...args) => {
    const fnKey = `${fn.name}(${args})`;
    if(!cache[fnKey]) {
      cache[fnKey] = fn(...args);
    }

    return cache[fnKey]
  };
}

और बस इतना ही।

अब मैं जाऊंगा और देखूंगा कि इसे "ठीक से" कैसे किया जाना चाहिए। लेकिन अगर आपको यह दिलचस्प लगे तो मुझे बताएं। यदि इस दृष्टिकोण (आपके स्वाद के लिए) में कुछ अस्पष्ट या गलत है, तो बस टिप्पणी छोड़ें और आइए इसके बारे में बात करें।

धन्यवाद फिर मिलेंगे!