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

कुछ गहन संचालन को छोड़ना एक बहुत ही सामान्य अनुकूलन तकनीक है। हर बार जब आप कुछ नहीं कर सकते - न करें। कैश - memcache , file cache , local cache - किसी भी कैश का उपयोग करने का प्रयास करें! बैकएंड सिस्टम और अतीत और वर्तमान के किसी भी बैकएंड सिस्टम का एक महत्वपूर्ण हिस्सा होना चाहिए।

संस्मरण बनाम कैशिंग

संस्मरण कैशिंग की तरह है। बस थोड़ा सा अलग है। कैश नहीं, चलो इसे काश कहते हैं।

लंबी कहानी छोटी है, लेकिन संस्मरण कैश नहीं है, लगातार कैश नहीं है। यह एक सर्वर साइड पर हो सकता है, लेकिन क्लाइंट साइड पर कैश नहीं होना चाहिए। यह उपलब्ध संसाधनों, उपयोग पैटर्न और उपयोग करने के कारणों के बारे में अधिक है।

समस्या - कैश को "कैश कुंजी" की आवश्यकता है

कैश स्ट्रिंग स्ट्रिंग key का उपयोग करके डेटा संग्रहीत और प्राप्त कर रहा है। यह पहले से ही एक अद्वितीय और प्रयोग करने योग्य कुंजी का निर्माण करने के लिए एक समस्या है, लेकिन फिर आपको अभी तक फिर से स्ट्रिंग आधारित माध्यमों को संग्रहीत करने के लिए क्रमबद्ध और डी-क्रमबद्ध डेटा रखना होगा ... संक्षेप में - कैश उतना तेज़ नहीं हो सकता है, जितना आप सोच सकते हैं। विशेष रूप से वितरित कैश।

संस्मरण के लिए किसी कैशे की जरूरत नहीं है

एक ही समय में - संस्मरण के लिए कोई कुंजी की आवश्यकता नहीं है। आमतौर पर * यह तर्कों का उपयोग करता है-जैसे, उनमें से एक भी कुंजी बनाने की कोशिश नहीं कर रहा है, और परिणामों को संग्रहीत करने के लिए विश्व स्तर पर उपलब्ध कुछ साझा वस्तु का उपयोग नहीं करता है, जैसा कि आमतौर पर कैश करता है।

ज्ञापन और कैश के बीच का अंतर API INTERFACE में है !

आमतौर पर * का मतलब हमेशा नहीं होता है। Lodash.memoize , डिफ़ॉल्ट रूप से, पास किए गए तर्कों को स्ट्रिंग कैश में बदलने के लिए JSON.stringify का उपयोग करता है (यह किसी भी अन्य तरीके से है! नहीं!)। सिर्फ इसलिए कि वे इस वस्तु का उपयोग किसी आंतरिक वस्तु तक पहुँचने के लिए करने जा रहे हैं, एक कैश्ड मूल्य को पकड़े हुए। फास्ट-मेमोइज़ , "सबसे तेज़ संभव संस्मरण लाइब्रेरी", वही करता है। दोनों नामित पुस्तकालय संस्मरण पुस्तकालय नहीं हैं, लेकिन कैश पुस्तकालय हैं।

यह उल्लेख के लायक है - JSON.stringify एक फ़ंक्शन की तुलना में 10 गुना धीमा हो सकता है, आप याद रखने वाले हैं।

जाहिर है - समस्या का उपमा समाधान कैश कुंजी का उपयोग नहीं करना है, और उस कुंजी का उपयोग करके कुछ आंतरिक कैश का उपयोग नहीं करना है। इसलिए - अंतिम तर्क याद रखें जिन्हें आप के साथ बुलाया गया था। जैसे संस्मरणात्मक या वैराग्य करना।

संस्मरण संभवतः एकमात्र सामान्य कैशिंग लाइब्रेरी है जिसका आप उपयोग करना चाहते हैं।

कैश आकार

सभी पुस्तकालयों के बीच दूसरा बड़ा अंतर कैश आकार और कैश संरचना के बारे में है।

क्या आपने कभी सोचा है - क्यों reselect या memoize-one ही अंतिम परिणाम रखता है? "कैश परिणाम का उपयोग नहीं करने के लिए एक से अधिक परिणाम स्टोर करने में सक्षम होने के लिए नहीं" , लेकिन क्योंकि केवल एक अंतिम परिणाम से अधिक स्टोर करने के लिए कोई कारण नहीं हैं।

... यह अधिक है:

• उपलब्ध संसाधन - एक एकल कैश लाइन बहुत ही संसाधन के अनुकूल है
• उपयोग पैटर्न - कुछ याद रखना "जगह में" एक अच्छा पैटर्न है। "जगह में" आपको आमतौर पर केवल एक, अंतिम, परिणाम की आवश्यकता होती है।
• -मॉड्यूलरिटी, आइसोलेशन और मेमोरी सेफ्टी के इस्तेमाल की वजह अच्छे कारण हैं। अपने शेष एप्लिकेशन के साथ कैश साझा नहीं करना कैश टक्कर के संदर्भ में अधिक सुरक्षित है।

एक एकल परिणाम?!

हां - केवल एक परिणाम। एक परिणाम के साथ कुछ शास्त्रीय चीजों को याद किया , जैसे मेमोफाइड रिट्रेसमेंट नंबर जनरेशन ( आप मेमोइज़ेशन के बारे में हर लेख में एक उदाहरण के रूप में पा सकते हैं ) संभव नहीं होगा। लेकिन, आम तौर पर, आप कुछ और कर रहे हैं - जिसे फ्रंटेंड पर एक रिट्रेसमेंट की आवश्यकता है? बैकएंड पर? एक वास्तविक दुनिया के उदाहरण सार आईटी क्विज़ से काफी दूर हैं।

लेकिन फिर भी, एकल-मूल्य संस्मरण प्रकार के बारे में दो BIG समस्याएं हैं।

समस्या 1 - यह "नाजुक" है

चूक से - सभी तर्क मेल खाना चाहिए, बिल्कुल "===" समान होना चाहिए। यदि एक तर्क मेल नहीं खाता है - खेल खत्म हो गया है। यहां तक ​​कि अगर यह संस्मरण के विचार से आता है - जो आजकल आप चाहते हैं कि कुछ नहीं हो सकता है। मेरा मतलब है - आप जितना संभव हो, और जितनी बार संभव हो, याद करना चाहते हैं।

यहां तक ​​कि कैश मिस एक कैश है जो हेडशॉट मिटा देता है।

"कल" से "आजकल" के बीच थोड़ा अंतर है - अपरिवर्तनीय डेटा संरचनाएं, जिसका उपयोग Redux में उदाहरण के लिए किया जाता है।

 const getSomeDataFromState = memoize(state => compute(state.tasks)); 

अच्छी लग रही है? सही लग रही है? हालाँकि जब कार्य नहीं हुआ था तब थेस्टेट बदल सकता है और आपको मिलान के लिए केवल कार्यों की आवश्यकता है।

स्ट्रक्चरल सेलेक्टर्स दिन को अपने सबसे मजबूत योद्धा - रेसेलेक्ट - को अपनी गोदी और कॉल के साथ सहेजने के लिए यहां हैं। रेसेलेट केवल मेमोएज़ेशन लाइब्रेरी नहीं है, बल्कि यह पावर मेमोइज़ेशन कैस्केड्स या लेंस (जो वे नहीं हैं, लेकिन ऑप्टिकल लेंस के रूप में चयनकर्ताओं के बारे में सोचते हैं) से आती है।

 // every time `state` changes, cached value would be rejected const getTasksFromState = createSelector(state => state.tasks); const getSomeDataFromState = createSelector( // `tasks` "without" `state` getTasksFromState, // <---------- // and this operation would be memoized "more often" tasks => compute(state.tasks) ); 

नतीजतन, अपरिवर्तनीय डेटा के मामले में - आपको हमेशा पहले उस डेटा टुकड़े में "फ़ोकस" करना होगा जो आपको वास्तव में चाहिए, और फिर - गणना करें, या फिर कैश को अस्वीकार कर दिया जाएगा, और ज्ञापन के पीछे का सारा विचार गायब हो जाएगा।

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

आइडिया उस डेटा पर "फोकस" करने के बारे में है जिस पर आप निर्भर हैं

मेरे पास दो पल होने चाहिए - उल्लेख:

• lodash.memoize और fast-memoize आपके डेटा को एक कुंजी के रूप में उपयोग करने के लिए एक स्ट्रिंग में परिवर्तित कर रहे हैं। इसका मतलब है कि वे 1 हैं) तेज 2 नहीं) सुरक्षित 3 नहीं) झूठी सकारात्मक उत्पन्न कर सकते हैं - कुछ अलग डेटा में समान स्ट्रिंग प्रतिनिधित्व हो सकता है। यह "कैश हॉट रेट" में सुधार कर सकता है, लेकिन वास्तव में एक बहुत बुरा काम है।
• ES6 प्रॉक्सी दृष्टिकोण है, दिए गए चर के सभी उपयोग किए गए टुकड़ों को ट्रैक करने और केवल कुंजियों की जांच करने के बारे में जो मायने रखते हैं। हालांकि मैं व्यक्तिगत रूप से डेटा चयनकर्ताओं के असंख्य बनाना चाहता हूं - आप इस प्रक्रिया को पसंद या समझ नहीं सकते हैं, लेकिन बॉक्स के बाहर उचित संस्मरण करना चाहते हैं - फिर मेमोइज़-स्टेट का उपयोग कर सकते हैं ।

समस्या 2- यह "एक कैश लाइन" है

अनंत कैश आकार एक हत्यारा है। कोई भी अनियंत्रित कैश एक हत्यारा है, जब तक कि स्मृति काफी परिमित है। इसलिए - सभी सर्वश्रेष्ठ पुस्तकालय "वन-कैश-लाइन-लॉन्ग" हैं। यह एक विशेषता और मजबूत डिजाइन निर्णय है। मैंने बस लिखा कि यह कितना सही है, और, मेरा विश्वास करो - यह वास्तव में सही बात है , लेकिन यह अभी भी एक समस्या है। एक बड़ी समस्या।

 const tasks = getTasks(state); // let's get some data from state1 (function was defined above) getDataFromTask(tasks[0]); // Yep! equal(getDataFromTask(tasks[0]), getDataFromTask(tasks[0])) // Ok! getDataFromTask(tasks[1]); // a different task? What the heck? // oh! That's another argument? How dare you!? // TLDR -> task[0] in the cache got replaced by task[1] you cannot use getDataFromTask to get data from different tasks 

एक बार एक ही चयनकर्ता को अलग-अलग स्रोत डेटा के साथ काम करना पड़ता है, जिसके साथ एक - सब कुछ टूट जाता है। और समस्या में भागना आसान है:

• जब तक हम किसी राज्य से कार्य प्राप्त करने के लिए चयनकर्ताओं का उपयोग कर रहे थे - हम किसी कार्य से कुछ प्राप्त करने के लिए समान चयनकर्ताओं का उपयोग कर सकते थे। तीव्र एपीआई से ही आता है। लेकिन यह काम नहीं करता है तो आप केवल अंतिम कॉल को याद कर सकते हैं, लेकिन कई डेटा स्रोतों के साथ काम करना होगा।
• एक ही समस्या कई रिएक्ट घटकों के साथ है - वे सभी एक ही हैं, और सभी अलग-अलग हैं, विभिन्न कार्यों को प्राप्त कर रहे हैं, एक दूसरे के परिणाम मिटा रहे हैं।

3 संभावित समाधान हैं:

• redux के मामले में - mapStateToProps कारखाने का उपयोग करें। यह प्रति-आवृत्ति संस्मरण पैदा करेगा।
  

   const mapStateToProps = () => { const selector = createSelector(...); // ^ you have to define per-instance selectors here // usually that's not possible :) return state => ({ data: selector(data), // a usual mapStateToProps }); } 

• दूसरा संस्करण लगभग एक ही है (और रिडक्स के लिए भी) - यह फिर से आकार का उपयोग करने के बारे में है। यह एक जटिल पुस्तकालय है, जो घटकों को भेद कर दिन बचा सकता है। यह सिर्फ समझ सकता है, कि नया कॉल "अन्य" घटक के लिए किया गया था, और यह "पिछले" के लिए कैश रख सकता है।

यह लाइब्रेरी आपको संस्मरण कैश को "रखने" में मदद करेगी, लेकिन इसे हटा नहीं। विशेष रूप से क्योंकि यह किसी भी मामले में फिट होने के लिए 5 (FIVE!) विभिन्न कैश रणनीतियों को लागू कर रहा है। यह एक बुरी गंध है। यदि आप गलत को चुनते हैं तो क्या होगा?
आपके द्वारा याद किए गए सभी डेटा - आपको इसे जल्दी या बाद में भूलना होगा। बिंदु अंतिम फ़ंक्शन आह्वान को याद नहीं करना है - यह बिंदु सही समय पर आईटी को भूल जाना है। बहुत जल्द नहीं, और संस्मरण को बर्बाद करना, और बहुत देर नहीं।

विचार आया? अब इसे भूल जाओ! और तीसरा संस्करण कहाँ है ??

एक विराम लेते हैं

बंद करो। रिलैक्स। गहरी सांस लें। और एक सरल प्रश्न का उत्तर दें - लक्ष्य क्या है? लक्ष्य तक पहुँचने के लिए हमें क्या करना होगा? क्या दिन बचाना होगा?

सुझाव: वह कहाँ है *** च "कैश"!

वह "कैश" कहां है? हां - यह सही सवाल है। यह पूछने के लिए धन्यवाद। और जवाब सरल है - यह एक बंद में स्थित है। एक छिपे हुए स्थान में * एक याद समारोह। उदाहरण के लिए - यहाँ memoize-one कोड है:

 function(fn) { let lastArgs; // the last arguments let lastResult;// the last result <--- THIS IS THE CACHE // the memoized function const memoizedCall = function(...newArgs) { if (isEqual(newArgs, lastArgs)) { return lastResult; } lastResult = resultFn.apply(this, newArgs); lastArgs = newArgs; return lastResult; }; return memoizedCall; } 

आपको एक memoizedCall दिया जाएगा, और यह पास के अंतिम परिणाम को अपने स्थानीय क्लोजर के अंदर रखेगा, मेमोइकॉल को छोड़कर, किसी के द्वारा भी सुलभ नहीं होगा। एक सुरक्षित जगह। "यह" एक सुरक्षित स्थान है।

Reselect एक ही करता है, और एक "कांटा" बनाने का एकमात्र तरीका, एक और कैश के साथ - एक नया संस्मरण बंद करना।

लेकिन (एक और) मुख्य सवाल - जब यह (कैश) "चला गया" होगा?

TLDR: यह एक फ़ंक्शन के साथ "चला गया" होगा, जब फ़ंक्शन उदाहरण गारबेज कलेक्टर द्वारा खाया जाएगा।

उदाहरण? उदाहरण! तो - प्रति उदाहरण ज्ञापन के बारे में क्या है? प्रतिक्रिया प्रलेखन में इसके बारे में एक पूरा लेख है

संक्षेप में - यदि आप कक्षा-आधारित प्रतिक्रिया घटकों का उपयोग कर रहे हैं, तो आप कर सकते हैं:

 import memoize from "memoize-one"; class Example extends Component { filter = memoize( // <-- bound to the instance (list, filterText) => list.filter(...); // ^ that is "per instance" memoization // we are creating "own" memoization function // with the "own" lastResult render() { // Calculate the latest filtered list. // If these arguments haven't changed since the last render, // `memoize-one` will reuse the last return value. const filteredList = this.filter(something, somehow); return <ul>{filteredList.map(item => ...}</ul> } } 

तो - जहां "lastResult" संग्रहीत है? इस वर्ग के उदाहरण के अंदर, मेमोइज्ड फ़िल्टर के एक स्थानीय दायरे के अंदर। और, जब यह "चला गया" होगा?

इस बार यह एक श्रेणी उदाहरण के साथ "चला गया" होगा। एक बार घटक अनमाउंट हो गया - यह एक ट्रेस के बिना चला गया। यह एक वास्तविक "प्रति उदाहरण" है, और आप इसका उपयोग कर सकते हैं। this.lastResult परिणाम वास्तव में समान "ज्ञापन" प्रभाव के साथ, एक लौकिक परिणाम रखने के लिए है।

React.Hooks के बारे में क्या है

हम करीब आ रहे हैं। Redux हुक में कुछ संदिग्ध कमांड होते हैं, जो, संभवतः, मेमोएज़ेशन के बारे में हैं। जैसे - useMemo , useCallback , useRef

लेकिन सवाल - जहां यह इस बार एक यादगार मूल्य का भंडारण कर रहा है?

संक्षेप में - यह इसे "हुक" में संग्रहीत करता है, एक VDOM तत्व के एक विशेष भाग के अंदर, जिसे वर्तमान तत्व से जुड़े फाइबर के रूप में जाना जाता है। एक समानांतर डेटा संरचना के भीतर।

इतना छोटा नहीं है - हुक आपके प्रोग्राम के काम करने के तरीके को बदल रहा है, आपके फ़ंक्शन को एक दूसरे के अंदर ले जा रहा है, जिसमें कुछ चर एक माता-पिता के बंद होने के अंदर छिपे हुए स्थान पर हैं । इस तरह के कार्यों को संदिग्ध या फिर से शुरू होने वाले कार्यों के रूप में जाना जाता है - कोरटाइन जावास्क्रिप्ट में वे आमतौर पर generators या async functions रूप में जाने जाते हैं।

लेकिन वह थोड़ा चरम पर है। एक बहुत ही कम समय में उपयोग मेमो इस में संस्मरण मूल्य का भंडारण कर रहा है। यह थोड़ा अलग है "यह"।

यदि हम एक बेहतर संस्मरण पुस्तकालय बनाना चाहते हैं तो हमें एक बेहतर "यह" खोजना चाहिए।

जिंग!

WeakMaps!

हाँ! WeakMaps! कुंजी-मूल्य को संग्रहीत करने के लिए, जहां कुंजी यह होगी, जब तक कि WeakMap इसके अलावा कुछ भी स्वीकार नहीं करता है, अर्थात "ऑब्जेक्ट"।

चलो एक सरल उदाहरण बनाते हैं:

 const createHiddenSpot = (fn) => { const map = new WeakMap(); // a hidden "closure" const set = (key, value) => (map.set(key, value), value); return (key) => { return map.get(key) || set(key, fn(key)) } } const weakSelect = createHiddenSpot(selector); weakSelect(todos); // create a new entry weakSelect(todos); // return an existing entry weakSelect(todos[0]); // create a new entry weakSelect(todos[1]); // create a new entry weakSelect(todos[0]); // return an existing entry! weakSelect(todos[1]); // return an existing entry!! weakSelect(todos); // return an existing entry!!! 

यह मूर्खतापूर्ण सरल है, और काफी "सही" है। तो "जब यह चला जाएगा"?

• कमजोर को भूल जाओ और एक पूरा "नक्शा" चला जाएगा
• टॉडोस को भूल जाओ [0] और उनकी कमजोर प्रविष्टि हो जाएगी
• todos भूल जाओ - और याद किया डेटा चला जाएगा!

यह स्पष्ट है कि जब कुछ "चला गया" होगा - केवल जब यह होना चाहिए!

जादुई रूप से - सभी reselect मुद्दे चले गए हैं। आक्रामक संस्मरण के मुद्दे - एक गोंनर भी।

यह दृष्टिकोण डेटा को तब तक याद रखता है जब तक कि उसे भूल न जाएं । यह अविश्वसनीय है, लेकिन कुछ बेहतर याद रखने के लिए आपको इसे बेहतर ढंग से भूलने में सक्षम होना चाहिए।

केवल एक चीज टिकती है - इस मामले के लिए एक अधिक मजबूत एपीआई बनाएं

काशे - एक कैश है

kashe WeakMap आधारित संस्मरण पुस्तकालय है, जो आपका दिन बचा सकता है।

यह पुस्तकालय 4 कार्यों को उजागर करता है

• kashe -से- kashe ।
• box - उपसर्ग संस्मरण के लिए, संस्मरण की संभावना बढ़ाने के लिए।
• inbox - नेस्टेड उपसर्ग संस्मरण, संस्मरण के परिवर्तन को कम करने के लिए
• fork - to fork (जाहिर है) संस्मरण।

काशे (fn) => संस्मरण (... args)

यह वास्तव में पिछले उदाहरण से एक createHiddenSpot है। यह आंतरिक WeakMap की कुंजी के रूप में पहले तर्क का उपयोग करेगा।

 const selector = (state, prop) => ({result: state[prop]}); const memoized = kashe(selector); const old = memoized(state, 'x') memoized(state, 'x') === old memoized(state, 'y') === memoized(state, 'y') // ^^ another argument // but old !== memoized(state, 'x') // 'y' wiped 'x' cache in `state` 

पहला तर्क एक कुंजी है, यदि आप फ़ंक्शन को फिर से एक ही कुंजी कहते हैं, लेकिन विभिन्न तर्क - कैश को बदल दिया जाएगा, यह अभी भी एक कैश लाइन लंबी संस्मरण है। इसे काम करने के लिए - आपको अलग-अलग मामलों के लिए अलग-अलग कुंजी प्रदान करनी होगी, जैसा कि मैंने एक कमजोर उदाहरण के साथ किया था, परिणाम प्रदान करने के लिए अलग-अलग प्रदान करने के लिए। रेसेलेट कैस्केड ए की बात अभी भी है।
सभी कार्य काश-यादगार नहीं हैं। पहले तर्क में एक ऑब्जेक्ट, एरे या एक फंक्शन होना चाहिए। यह WeakMap की कुंजी के रूप में उपयोग करने योग्य होना चाहिए।

बॉक्स (fn) => मेमोफ़िन 2 (बॉक्स, ... आर्ग्स)

यह एक ही कार्य है, बस दो बार लागू किया गया। एक बार fn के लिए, एक बार ज्ञापन के लिए, तर्कों की एक प्रमुख कुंजी जोड़कर। यह किसी भी समारोह को काश-यादगार बना सकता है।

यह काफी घोषणात्मक है - हे फ़ंक्शन! मैं इस बॉक्स में परिणाम संग्रहीत करूंगा।

 // could not be "kashe" memoized const addTwo = (a,b) => ({ result: a+b }); const bAddTwo = boxed(addTwo); const cacheKey = {}; // any object bAddTwo(cacheKey, 1, 2) === bAddTwo(cacheKey, 1, 2) === { result: 3} 

यदि आप पहले से ही संस्मरण समारोह को बॉक्स करेंगे - तो आप संस्मरण के अवसर को बढ़ाएंगे, उदाहरण के अनुसार संस्मरण - आप संस्मरण कैस्केड बना सकते हैं।

 const selectSomethingFromTodo = (state, prop) => ... const selector = kashe(selectSomethingFromTodo); const boxedSelector = kashe(selector); class Component { render () { const result = boxedSelector(this, todos, this.props.todoId); // 1. try to find result in `this` // 2. try to find result in `todos` // 3. store in `todos` // 4. store in `this` // if multiple `this`(components) are reading from `todos` - // selector is not working (they are wiping each other) // but data stored in `this` - exists. ... } } 

इनबॉक्स (fn) => मेमोफाइना 2 (बॉक्स, ... आर्ग्स)

यह एक बॉक्स के विपरीत है, लेकिन लगभग एक ही तरह से, नेस्टेड कैश को कमांड बॉक्स में डेटा स्टोर करने के लिए कमांड करता है। एक दृष्टिकोण से - यह संस्मरण संभावना को कम करता है (कोई संस्मरण कैस्केड नहीं है), लेकिन दूसरे से - यह कैश टकराव को हटाता है और प्रक्रियाओं को अलग करने में मदद करता है यदि उन्हें किसी भी कारण से एक दूसरे के साथ हस्तक्षेप नहीं करना चाहिए।

यह काफी घोषणात्मक है - हे! अंदर सब लोग! यहाँ एक बॉक्स का उपयोग करना है

 const getAndSet = (task, number) => task.value + number; const memoized = kashe(getAndSet); const inboxed = inbox(getAndSet); const doubleBoxed = inbox(memoized); memoized(task, 1) // ok memoized(task, 2) // previous result wiped inboxed(key1, task, 1) // ok inboxed(key2, task, 2) // ok // inbox also override the cache for any underlaying kashe calls doubleBoxed(key1, task, 1) // ok doubleBoxed(key2, task, 2) // ok 

कांटा (काश-मेमोइज़्ड) => काशे-मेमोइज़्ड

कांटा एक वास्तविक कांटा है - यह किसी भी काश-ज्ञापन फ़ंक्शन को प्राप्त करता है, और उसी को वापस करता है, लेकिन एक और आंतरिक कैश प्रविष्टि के साथ। Redux mapStateToProps फैक्टरी विधि याद रखें?

 const mapStateToProps = () => { // const selector = createSelector(...); // const selector = fork(realSelector); // just fork existing selector. Or box it, or don't do anything // kashe is more "stable" than reselect. return state => ({ data: selector(data), }); } 

फिर से चुनें

और एक और बात जो आपको पता होनी चाहिए - काश reselect की जगह ले सकती थी। सचमुच।

 import { createSelector } from 'kashe/reselect'; 

यह वास्तव में एक ही reselect है, बस एक संस्मरण समारोह के रूप में kashe के साथ बनाया गया है।

Codesandbox

यहाँ थोड़ा उदाहरण के साथ खेलना है। इसके अलावा आप परीक्षण की दोहरी जांच कर सकते हैं - वे कॉम्पैक्ट और ध्वनि हैं।
यदि आप कैशिंग और संस्मरण के बारे में अधिक जानना चाहते हैं - तो जांचें कि मैंने एक साल पहले सबसे तेज संस्मरण पुस्तकालय कैसे लिखा था।

पुनश्च: यह उल्लेख के लायक है, इस दृष्टिकोण के सरल संस्करण की तुलना में - कमजोर-मेमोइज़ - का उपयोग थोड़ी देर के लिए भावना-जेएस में किया जाता है। कोई शिकायत नहीं। नैनो-मेमोइज़ एकल तर्क मामले के लिए WeakMaps का भी उपयोग करता है।

बात समझ में आई? एक अधिक "कमजोर" दृष्टिकोण आपको बेहतर कुछ याद रखने में मदद करेगा, और इसे बेहतर ढंग से भूल जाएगा।

https://github.com/theKashey/kashe

हाँ, कुछ भूलने के बारे में, - क्या आप कृपया यहाँ देख सकते हैं?