एक समस्या की कहानी: सबसे छोटा जावास्क्रिप्ट ज्ञापन

यह सेंट पीटर्सबर्ग में वार्षिक होल्जेस सम्मेलन की पूर्व संध्या पर हुआ था। हमारी कंपनी कई वर्षों से एक प्रायोजक है: तदनुसार, देखभाल करने वाले डेवलपर्स के जिज्ञासु मन के लिए दिलचस्प रुचियों के साथ इसका अपना स्टैंड भी है। जब मुख्य पाठ्यक्रम तैयार था और सभी कार्यों की समीक्षा की गई और वकीलों द्वारा पूरा किया गया, तो मैंने अपने सहयोगियों को रात में कुछ और बौद्धिक भोजन देने का फैसला किया:

एक संस्मरण लिखें - एक डेकोरेटर फ़ंक्शन जो दोहराए गए गणनाओं को रोकने के लिए एक लिपटे फ़ंक्शन को निष्पादित करने के परिणामों को बचाता है। आपके पास केवल 50 अक्षर हैं।

भाषा, निश्चित रूप से, जावास्क्रिप्ट है । कार्य स्वयं एक क्लासिक है, लेकिन 50-चरित्र की सीमा एक वास्तविक चुनौती में बदल गई।

सम्मेलन के पहले दिन के ब्रेक में, हमने लक्ष्य प्राप्त करने के विकल्पों पर चर्चा की, धीरे-धीरे प्रतिक्रिया को कम किया। सम्मेलन के सभी प्रतिभागियों के साथ कार्य को साझा करने के विचार के साथ सभी प्रचारों का ताज पहनाया गया था, और दूसरे दिन हमने कार्य को देखा (परिशिष्ट देखें) और जो चाहते थे, उन्हें फॉर्म वितरित करना शुरू कर दिया। परिणामस्वरूप, हमें लगभग 40 समाधान मिल गए और एक बार फिर से js-Developers के असाधारण समुदाय के बारे में आश्वस्त हो गए, लेकिन दमित्री कटावे का 53 अक्षरों का रिकॉर्ड (SEMrush) बना रहा। चलो यह पता लगाने!

आदतन अमल

function memoize(f) { let cache = {}; return function ret() { let key = JSON.stringify(arguments); if (!cache.hasOwnProperty(key)) { cache[key] = f.apply(this, arguments); } return cache[key]; } } 

परिणाम: ~ 190 वर्ण

• ज्ञापन - हमारा संस्मरण
• च - सजाया, लिपटे समारोह
• परिणामी फ़ंक्शन

जवाब पाने के लिए - फ़ंक्शन का आकार - हम उपयोग करते हैं:

 memoize.toString().replace(/\s+/g, ' ').length 

किसी फ़ंक्शन के आकार का मूल्यांकन करते समय, हम उसके शरीर और मापदंडों की एक सूची पर ध्यान देते हैं। यदि फ़ंक्शन अनाम है, तो घोषणा को ध्यान में नहीं रखा जाता है।

दुरुपयोग के बाद स्वास्थ्य परीक्षण के लिए सरल परीक्षण:

 const log = memoize(console.log); const inc = memoize(o => ox + 1); 

अगला, प्रत्येक कार्यान्वयन के परिणाम को परीक्षा परिणाम द्वारा चिह्नित किया जाएगा।

नेट कार्यान्वयन

सबसे पहले, मैं तीर फ़ंक्शन के पक्ष में फ़ंक्शन घोषणा से छुटकारा चाहता हूं, क्योंकि हम इस संदर्भ में रुचि नहीं रखते हैं, हम तर्कों के लिए अपील नहीं करते हैं , और एक निर्माता के रूप में हम नए के माध्यम से कॉल करने का इरादा नहीं करते हैं। उसी समय, हम उपयोग किए गए स्थानीय चर के नाम को कम कर देंगे:

 const memoize = f => { let c = {}; return function() { let k = JSON.stringify(arguments); if (!c.hasOwnProperty(k)) { c[k] = f.apply(this, arguments); } return c[k]; } } 

परिणाम: 154 , परीक्षण उत्तीर्ण

फिर हम परिणामी फ़ंक्शन के साथ एक समान ऑपरेशन कर सकते हैं, लेकिन वहां हमें तर्क की आवश्यकता होती है । यहां प्रसार ऑपरेटर बचाव में आता है, हमें सरणी चर ए के साथ तर्कों के पारित होने योग्य ऑब्जेक्ट को बदलने की अनुमति देता है। इसके अलावा, हम अब इस संदर्भ को सजाए जा रहे फ़ंक्शन को पास नहीं करेंगे: यदि आवश्यक हो, तो फ़ंक्शन .prototyp.bind या हमारी पॉलीफ़िल मदद करेगी।

 const memoize = f => { let c = {}; return (...a) => { let k = JSON.stringify(a); if (!c.hasOwnProperty(k)) { c[k] = f(...a); } return c[k]; } } 

परिणाम: 127 , परीक्षण पारित

अब हम परिणामी फ़ंक्शन के शरीर की ओर मुड़ते हैं। जाहिर है, कैश में चाबी ढूंढना और मूल्य वापस करना बोझिल है। आइए कम करने की कोशिश करें कि कैसे:

 const memoize = f => { let c = {}; return (...a) => { let k = JSON.stringify(a); return c[k] || (c[k] = f(...a)); } } 

परिणाम: 101 , परीक्षण 3 और 4 गिर गए

यहाँ हम hasOwnProperty विधि का परित्याग करते हैं। हम इसे बर्दाश्त कर सकते हैं, क्योंकि JSON.stringify के माध्यम से तर्कों की सरणी को क्रमबद्ध करने का परिणाम हमेशा "[...]" होगा और यह संभावना नहीं है कि ऐसी संपत्ति प्रोटोटाइप कैश ( ऑब्जेक्ट ) में दिखाई देगी ।

इसके बाद, हम "लॉजिकल" या ऑपरेटर की सुविधा का उपयोग करते हैं यदि पहली अभिव्यक्ति को वापस लौटाया जाए, तो इसे सही में बदला जा सकता है , या अन्यथा, पिछले फ़ंक्शन गणना के साथ दूसरा।

और यहां हम परीक्षण 3 और 4 गिर गए। ऐसा इसलिए हुआ क्योंकि सजाए गए फ़ंक्शन कंसोल.लॉग एक मान नहीं लौटाते हैं: परिणाम अपरिभाषित होगा। हम इसे कैश में डालते हैं, और जब हम इसे फिर से कॉल करते हैं, तो हम डिस्जेनरेटर सुविधा के माध्यम से जांचने का प्रयास करते हैं, हम पहले वाले ऑपरेंड में निहित रूप से झूठे प्रदर्शित होते हैं और, तदनुसार, दूसरे में मिलते हैं, जो फ़ंक्शन कॉल की ओर जाता है। यह प्रभाव घटे हुए सभी परिणामों के लिए घटित होगा: 0, "", अशक्त, NaN , आदि।

OR या यदि कथन के बजाय , हम एक सशर्त टर्नरी ऑपरेटर का उपयोग कर सकते हैं:

 const memoize = f => { let c = {}; return (...a) => { let k = JSON.stringify(a); return c.hasOwnProperty(k) ?c[k] :c[k] = f(...a); } } 

परिणाम: 118 , परीक्षण उत्तीर्ण

बहुत कम घटा। लेकिन क्या होगा यदि आप एक साधारण वस्तु के बजाय मानचित्र को भंडारण के रूप में उपयोग करते हैं? एक छोटी विधि भी है:

 const memoize = f => { let c = new Map; return (...a) => { let k = JSON.stringify(a); return (c.has(k) ?c :c.set(k, f(...a))).get(k); } } 

परिणाम: 121 , परीक्षण उत्तीर्ण

पूरी तरह से विफल हो। लेकिन मानचित्र को तुरंत त्याग दें इसके लायक नहीं है। की-वैल्यू स्टोरेज का यह कार्यान्वयन आपको ऑब्जेक्ट को एक कुंजी के रूप में उपयोग करने की अनुमति देता है। और इसका मतलब है, क्या हमें JSON.stringify बिल्कुल छोड़ देना चाहिए?

 const memoize = f => { let c = new Map; return (...a) => (c.has(a) ?c :c.set(a, f(...a))).get(a); } 

परिणाम: 83 , परीक्षण 3 और 4 गिर गए

यह बहुत ही आशाजनक लग रहा है! हालाँकि, परीक्षण 3 और 4 फिर से गिरना शुरू हो गए। इसका कारण यह है कि मैप ऑब्जेक्ट में कुंजियों की तुलना SameValueZone एल्गोरिथ्म का उपयोग करके लागू की गई है। यदि आप NaN, -0 और 0 के साथ विवरण को छोड़ देते हैं, तो यह सख्त तुलना ऑपरेटर ( === ) के समान काम करता है। और हमारे पास लिपटे फ़ंक्शन के प्रत्येक कॉल के लिए तर्कों (और इसलिए एक ऑब्जेक्ट) का एक नया सरणी है, यहां तक ​​कि समान मूल्यों के साथ भी। तुलना वस्तु के संदर्भ के अनुसार होती है और इसलिए Map.prototyp.has विधि कभी भी कुछ भी नहीं खोज पाएगी ।

इस प्रकार, मैप के उपयोग ने हमें hasOwProperty या JSON.stringify को कम नहीं किया है ।

ऑपरेटर बचाव में आता है, जो किसी वस्तु में या उसके प्रोटोटाइप की श्रृंखला में मौजूदगी की जाँच करता है। क्यों हम प्रोटोटाइप में खोज से डर नहीं सकते ऊपर बताए गए हैं।

 const memoize = f => { let c = {}; return (...a) => { let k = JSON.stringify(a); return k in c ?c[k] :c[k] = f(...a); } } 

परिणाम: 105 , परीक्षण उत्तीर्ण

ज्ञापनकर्ता और परिणामी फ़ंक्शन दोनों के शरीर में वापसी कथन में तर्क से पहले एक स्थानीय चर घोषित करने और शुरू करने की आवश्यकता के साथ दो अभिव्यक्तियाँ हैं। क्या तीर के शरीर को एक अभिव्यक्ति से कम करना संभव है? बेशक, IIFE ( तुरंत इनवॉइस फंक्शन एक्सप्रेशन ) पैटर्न का उपयोग कर:

 const memoize = f => (c => (...a) => (k => k in c ?c[k] : c[k] = f(...a))(JSON.stringify(a)) )({}); 

परिणाम: 82 , परीक्षण उत्तीर्ण

यह अतिरिक्त स्थानों से छुटकारा पाने का समय है:

 f=>(c=>(...a)=>(k=>k in c?c[k]:c[k]=f(...a))(JSON.stringify(a)))({}); 

परिणाम: 68 , परीक्षण पास हुए

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

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

 f=>(c=>(...a)=>a in c?c[a]:c[a]=f(...a))({}); 

परिणाम: 44 , परीक्षण 6 गिर गया

टेस्ट 6 बस गिरना शुरू हो रहा है। ऐसा लगता है कि रिटर्न वैल्यू टेस्ट में पिछले फ़ंक्शन कॉल का परिणाम है। ऐसा क्यों हो रहा है? हां, हमने तर्क ऑब्जेक्ट के लिए कॉल को हटा दिया है, लेकिन हमने इस बात पर ध्यान नहीं दिया कि कोई भी तर्क एक जटिल ऑब्जेक्ट हो सकता है, जिससे कॉल करते हुए हम सभी की पसंदीदा [ऑब्जेक्ट ऑब्जेक्ट] प्राप्त कर सकते हैं । इसका मतलब यह है कि तर्कों {x: 1} और {x: 2} हैश में एक ही कुंजी का उपयोग करेंगे।

बेस 64 में कन्वर्ट करने के लिए इस्तेमाल किया जाने वाला बोटो सीरियलाइज़ेशन फंक्शन के लिए एक अच्छा दावेदार था। लेकिन वह पहले स्ट्रिंग की ओर जाता है, इसलिए कोई मौका नहीं। हमने URI बनाने और एक ArrayBuffer बनाने की दिशा में सोचा, हैश या क्रमबद्ध मान प्राप्त करने के लिए कोई भी कार्य किया। लेकिन वे यथावत रहे।

वैसे, JSON.stringify की अपनी ख़ासियतें हैं : इन्फिनिटी, NaN, अपरिभाषित, प्रतीक को शून्य में डाल दिया जाएगा। वही फ़ंक्शंस के लिए जाता है। यदि संभव हो, तो ऑब्जेक्ट से एक अंतर्निहित कॉल toJSON होता है, और मैप और सेट को केवल प्रगणित तत्वों द्वारा दर्शाया जाएगा। यह समझने योग्य है, जिसे अंतिम प्रारूप दिया गया है: JSON।

आगे क्या?

विषाक्त संशोधन

हम सभी निश्चित रूप से शुद्ध कार्यों से प्यार करते हैं, लेकिन समस्या का सामना करने में, ऐसी आवश्यकता इसके लायक नहीं है। और इसका मतलब है कि यह एक चुटकी साइड-इफेक्ट्स जोड़ने का समय है।

सबसे पहले, कैश को इस प्रकार क्यों नहीं शुरू करना चाहिए:

 (f,c={})=>(...a)=>(k=>k in c?c[k]:c[k]=f(...a))(JSON.stringify(a)); 

परिणाम: 66 , परीक्षण उत्तीर्ण

यहां हम एरो फ़ंक्शन में डिफ़ॉल्ट पैरामीटर का उपयोग करते हैं। बेशक, हम ग्राहक को अपना कैश सेट करने का अवसर देते हैं, तो क्या? लेकिन हमने 2 अक्षर कम कर दिए।

किसी अन्य समारोह को सजाने के लिए मैं कैश कैसे शुरू कर सकता हूं? सही उत्तर: हमें इसे आरंभ करने की आवश्यकता क्यों है? लिपटे जाने के लिए किसी फ़ंक्शन के संदर्भ में तैयार कुछ का उपयोग क्यों न करें। लेकिन क्या होगा अगर फंक्शन ही हो? हम सभी जानते हैं कि जावास्क्रिप्ट में कार्य भी वस्तु हैं:

 f=>(...a)=>(k=>k in f?f[k]:f[k]=f(...a))(JSON.stringify(a)); 

परिणाम: 59 , परीक्षण पास हुए

यहाँ JSON.stringify "[...]" में तर्कों को लपेटकर ऑब्जेक्ट (फ़ंक्शन) के अन्य गुणों और विधियों के साथ इंटरसेक्ट करने से बचाएगा।

इस क्षण में, पहले से लागू IIFE पैटर्न अब खुद को सही नहीं ठहरा रहा है। लेकिन वापसी के बयान से बचने के लिए तीर फ़ंक्शन के लिए एक एकल अभिव्यक्ति रखने की तत्काल आवश्यकता है:

 f=>(...a)=>(k=JSON.stringify(a),k in f?f[k]:f[k]=f(...a)); 

परिणाम: 57 , परीक्षाएं उत्तीर्ण

चूँकि हम ऐरो फ़ंक्शन में ब्लॉक स्टेटमेंट का उपयोग नहीं करते हैं, इसलिए हम एक वैरिएबल ( var या let ) की घोषणा नहीं कर सकते, लेकिन हम वैश्विक संदर्भ - साइड-इफ़ेक्ट का उपयोग कर सकते हैं! यहाँ संघर्ष पहले से ही होने की कुछ संभावना है।

अल्पविराम ऑपरेटर का उपयोग करते हुए , हम दो अभिव्यक्तियों को एक में समेटते हैं : ऑपरेंड का मूल्यांकन बाएं से दाएं किया जाता है, और परिणाम उत्तरार्द्ध का मूल्य है।

 f=>(...a)=>(k=JSON.stringify(a))in f?f[k]:f[k]=f(...a); 

परिणाम: 54 , परीक्षण पारित

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

और अंत में:

 f=>(...a)=>f[k=JSON.stringify(a)]=k in f?f[k]:f(...a); 

परिणाम: 53 , परीक्षण पास हुए

मूल्य पर पहुंचते समय कुंजी की गणना क्यों न करें। और फिर - एक ही टर्नरी ऑपरेटर और असाइनमेंट। कुल: 53 वर्ण!

क्या शेष 3 पात्रों को हटाना संभव है?

समझ

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

• एरो फंक्शन एक्सप्रेशन
• लेक्सिकल स्कूपिंग और IIFE
• ऐरे-जैसे तर्क वस्तु
• फैला हुआ, अल्पविराम या ऑपरेटर
• सख्त तुलना ऑपरेटर
• JSON.stringify औरString
• ऑपरेटर और hasOwnProperty में
• ग्रुपिंग ऑपरेटर और ब्लॉक स्टेटमेंट
• नक्शा वस्तु
• और कुछ और

ऐसी कहानियां किसी भाषा की बारीकियों के अध्ययन में खुद को विसर्जित करने का एक अच्छा कारण हैं, इसे बेहतर तरीके से समझने में मदद करें (या इसके विपरीत)। और हां, सिर्फ मनोरंजन के लिए!

आवेदन

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