EcmaScript के दृष्टिकोण से कार्यात्मक प्रोग्रामिंग। रचना, करी, आंशिक आवेदन

नमस्कार, हेब्र!

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

तो चलिए शुरू करते है!

मान लीजिए हमारे पास एक कार्य है: palindromes के साथ काम करने के लिए उपकरणों का एक सेट बनाने के लिए।

विलोमपद
पुरुष का लिंग
ऐसा शब्द या वाक्यांश जो बाएँ से दाएँ और दाएँ से बाएँ जाता है, उसी तरह पढ़ा जाता है।
"पी "मैं जज की तलवार के साथ जाता हूं"

इस कार्य के संभावित कार्यान्वयनों में से एक इस तरह दिख सकता है:

function getPalindrom (str) { const regexp = /[\.,\/#!$%\^&\*;:{}=\-_`~()?\s]/g; str = str.replace(regexp, '').toLowerCase().split('').reverse().join(''); // -       ,       return str; } function isPalindrom (str) { const regexp = /[\.,\/#!$%\^&\*;:{}=\-_`~()?\s]/g; str = str.replace(regexp, '').toLowerCase(); return str === str.split('').reverse().join(''); } 

बेशक, यह कार्यान्वयन काम करता है। हम उम्मीद कर सकते हैं कि अगर एपीआई सही डेटा लौटाता है तो गेटपाइंड्रोम सही ढंग से काम करेगा। IsPalindrom के लिए एक कॉल ('मैं एक तलवार न्यायाधीश के साथ जा रहा हूँ') सही लौटेगा, और isPalindrom ('नहीं एक palindrome') के लिए एक कॉल झूठी वापस आ जाएगी। क्या यह कार्यान्वयन कार्यात्मक प्रोग्रामिंग के आदर्शों के संदर्भ में अच्छा है? निश्चित रूप से अच्छा नहीं है!

इस लेख से शुद्ध कार्यों की परिभाषा के अनुसार:

शुद्ध कार्य (पीएफ) - हमेशा एक अनुमानित परिणाम लौटाते हैं।
पीएफ गुण:

पीएफ निष्पादन का परिणाम केवल पारित तर्कों और पीएफ को लागू करने वाले एल्गोरिदम पर निर्भर करता है
वैश्विक मूल्यों का उपयोग न करें
बाहर के मूल्यों या पारित तर्कों को संशोधित न करें
डेटा को फाइल, डेटाबेस या कहीं और न लिखें

और हम अपने उदाहरण में पलिंड्रोमस के साथ क्या देखते हैं?

सबसे पहले, कोड का दोहराव है, अर्थात। DRY के सिद्धांत का उल्लंघन किया गया है। दूसरे, getPalindrom फ़ंक्शन डेटाबेस तक पहुँचता है। तीसरा, फ़ंक्शंस उनके तर्कों को संशोधित करते हैं। कुल मिलाकर, हमारे कार्य साफ नहीं हैं।

परिभाषा को याद करें: कार्यात्मक प्रोग्रामिंग कार्यों के एक सेट को संकलित करने के माध्यम से कोड लिखने का एक तरीका है।

हम इस कार्य के लिए कार्यों का एक समूह बनाते हैं:

 const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g;//(1) const replace = (regexp, replacement, str) => str.replace(regexp, replacement);//(2) const toLowerCase = str => str.toLowerCase();//(3) const stringReverse = str => str.split('').reverse().join('');//(4) const isStringsEqual = (strA, strB) => strA === strB;//(5) ) const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g;//(1) const replace = (regexp, replacement, str) => str.replace(regexp, replacement);//(2) const toLowerCase = str => str.toLowerCase();//(3) const stringReverse = str => str.split('').reverse().join('');//(4) const isStringsEqual = (strA, strB) => strA === strB;//(5) 

पंक्ति 1 में, हमने नियमित अभिव्यक्ति को कार्यात्मक रूप में स्थिर घोषित किया। स्थिरांक का वर्णन करने की इस पद्धति का उपयोग अक्सर एफपी में किया जाता है। पंक्ति 2 में, हमने String.prototyp.replace पद्धति को एक कार्यात्मक एब्सट्रैक्शन में बदल दिया, ताकि यह (बदला हुआ कॉल) कार्यात्मक प्रोग्रामिंग अनुबंध के अनुरूप हो। लाइन 3 पर, String.prototype.toLowerCase के लिए एक अमूर्त तरीके से बनाया गया था। 4 वें में, उन्होंने एक फ़ंक्शन लागू किया जो पारित एक से एक नया विस्तारित स्ट्रिंग बनाता है। स्ट्रिंग समानता के लिए 5 वीं जांच।

कृपया ध्यान दें कि हमारी विशेषताएं बेहद साफ हैं! हमने पिछले लेख में शुद्ध कार्यों के लाभों के बारे में बात की थी।

अब हमें यह देखने के लिए चेक लागू करने की आवश्यकता है कि क्या स्ट्रिंग एक पैलिंड्रोम है। कार्यों की एक संरचना हमारी सहायता के लिए आएगी।

फ़ंक्शंस की संरचना एक निश्चित परिणामी फ़ंक्शन में दो या अधिक फ़ंक्शंस का संघ है, जो वांछित एल्गोरिथम क्रम में संयुक्त लोगों के व्यवहार को लागू करता है।

परिभाषा जटिल लग सकती है, लेकिन व्यावहारिक दृष्टि से यह उचित है।

हम यह कर सकते हैं:

 isStringsEqual(toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', '    ')), stringReverse(toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', '    ')))); 

या इस तरह:

 const strA = toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', '    ')); const strB = stringReverse(toLowerCase(replace(allNotWordSymbolsRegexpGlobal(), '', '    '))); console.log(isStringsEqual(strA, strB)); 

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

वास्तव में, जैसा कि आमतौर पर कार्यात्मक प्रोग्रामिंग में होता है, हमें बस एक और फ़ंक्शन लिखने की आवश्यकता है।

 const compose = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x); 

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

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

हालाँकि, पहले से ही अब हम अपने कोड में कंपोजीशन तकनीक को लागू करने में समस्याएँ देखते हैं, क्योंकि फ़ंक्शन

 const replace = (regexp, replacement, str) => str.replace(regexp, replacement); 

3 इनपुट मापदंडों को स्वीकार करने की उम्मीद है, और हम केवल एक रचना करने के लिए भेजते हैं। एक और एफपी तकनीक, करी, इस समस्या को हल करने में हमारी मदद करेगी।

क्यूरिंग एक तर्क से एक फ़ंक्शन के लिए कई तर्कों से एक फ़ंक्शन का रूपांतरण है।

पहले लेख से हमारा ऐड फंक्शन याद है?

 const add = (x,y) => x+y; 

यह इस तरह से किया जा सकता है:

 const add = x => y => x+y; 

फ़ंक्शन x लेता है और एक लैम्ब्डा लौटाता है जो वाई की अपेक्षा करता है और कार्रवाई करता है।

करी लाभ:

• कोड बेहतर दिखता है;
• करी कार्य हमेशा साफ होते हैं।

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

 const replaceAllNotWordSymbolsGlobal = replacement => str => replace(allNotWordSymbolsRegexpGlobal(), replacement, str); 

जैसा कि आप देख सकते हैं, हम एक स्थिर के साथ एक तर्क को ठीक करते हैं। यह इस तथ्य के कारण है कि करी वास्तव में आंशिक उपयोग का एक विशेष मामला है।

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

हमारे मामले में, हमने ReplaceAllNotWordSymbolsGlobal फ़ंक्शन बनाया, जो आंशिक रूप से लागू किया गया विकल्प है। यह प्रतिस्थापन को स्वीकार करता है, इसे एक क्लोजर में संग्रहीत करता है, और एक इनपुट लाइन की अपेक्षा करता है जिसके लिए यह प्रतिस्थापित कॉल करेगा, और हम एक निरंतर के साथ regexp।

वापस पलिंडोम्स में। पलिंड्रोम समय के लिए कार्यों की एक रचना बनाएँ:

 const processFormPalindrom = compose( replaceAllNotWordSymbolsGlobal(''), toLowerCase, stringReverse ); 

और उस पंक्ति के लिए कार्यों की संरचना, जिसके साथ हम संभावित तालमेल की तुलना करेंगे:

 const processFormTestString = compose( replaceAllNotWordSymbolsGlobal(''), toLowerCase, ); 

अब याद रखें कि हमने ऊपर क्या कहा था:

एक विशिष्ट रचना उदाहरण एक फ़ंक्शन को दूसरे के तर्क के रूप में कॉल कर रहा है

और नाम:

 const testString = '    ';//          , .. ,    ,  ,   -   ,    const isPalindrom = isStringsEqual(processFormPalindrom(testString), processFormTestString(testString)); 

यहां हमारे पास काम करने और अच्छा दिखने वाला समाधान है:

 const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g; const replace = (regexp, replacement, str) => str.replace(regexp, replacement); const toLowerCase = str => str.toLowerCase(); const stringReverse = str => str.split('').reverse().join(''); const isStringsEqual = (strA, strB) => strA === strB; const replaceAllNotWordSymbolsGlobal = replacement => str => replace(allNotWordSymbolsRegexpGlobal(), replacement, str); const compose = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x); const processFormPalindrom = compose( replaceAllNotWordSymbolsGlobal(''), toLowerCase, stringReverse ); const processFormTestString = compose( replaceAllNotWordSymbolsGlobal(''), toLowerCase, ); const testString = '    '; const isPalindrom = isStringsEqual(processFormPalindrom(testString), processFormTestString(testString)); 

हालाँकि, हम हर बार करी करना या आंशिक रूप से लागू कार्यों को अपने हाथों से बनाना नहीं चाहते हैं। बेशक, हम नहीं चाहते हैं, प्रोग्रामर आलसी लोग हैं। इसलिए, जैसा कि आम तौर पर एफपी में होता है, हम कुछ और कार्य लिखेंगे:

 const curry = fn => (...args) => { if (fn.length > args.length) { const f = fn.bind(null, ...args); return curry(f); } else { return fn(...args) } } 

करी फंक्शन करीने के लिए एक फंक्शन लेता है, इसे एक क्लोजर में स्टोर करता है, और एक लैम्ब्डा लौटाता है। लैंबडा ने फ़ंक्शन के बाकी तर्कों की अपेक्षा की है। हर बार एक तर्क प्राप्त होता है, यह देखने के लिए जांचता है कि क्या सभी घोषित तर्क स्वीकार किए जाते हैं। यदि स्वीकार किया जाता है, तो फ़ंक्शन कहा जाता है और इसका परिणाम वापस आ जाता है। यदि नहीं, तो फ़ंक्शन फिर से करी गई है।

हम खाली स्ट्रिंग के साथ नियमित अभिव्यक्ति को बदलने के लिए आंशिक रूप से लागू फ़ंक्शन भी बना सकते हैं:

 const replaceAllNotWordSymbolsToEmpltyGlobal = curry(replace)(allNotWordSymbolsRegexpGlobal(), ''); 

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

 const party = (fn, x) => (...args) => fn(x, ...args); 

यह आंशिक लागू कार्यों को बनाने के लिए एक अमूर्त कार्यान्वयन है। यह एक फ़ंक्शन लेता है और पहला तर्क देता है, एक लैम्ब्डा देता है जो बाकी की अपेक्षा करता है और फ़ंक्शन को निष्पादित करता है।

अब हम पार्टी को फिर से लिखते हैं ताकि हम कई तर्कों के आंशिक रूप से लागू फ़ंक्शन बना सकें:

 const party = (fn, ...args) => (...rest) => fn(...args.concat(rest)); 

यह अलग से ध्यान देने योग्य है कि इस तरह से किए गए कार्यों को घोषित (fn.length) से कम किसी भी तर्क के साथ बुलाया जा सकता है।

 const sum = (a,b,c,d) => a+b+c+d; const fn = curry(sum); const r1 = fn(1,2,3,4);//,   const r2 = fn(1, 2, 3)(4);//       const r3 = fn(1, 2)(3)(4); const r4 = fn(1)(2)(3)(4); const r5 = fn(1)(2, 3, 4); const r6 = fn(1)(2)(3, 4); const r7 = fn(1, 2)(3, 4); 

चलो हमारे पैलिन्ड्रोम पर वापस जाएं। हम अतिरिक्त कोष्ठक के बिना हमारे प्रतिस्थापनअनलॉटॉर्ड वर्डब्लाम्सटोमेलीग्लिट ​​को फिर से लिख सकते हैं:

 const replaceAllNotWordSymbolsToEmpltyGlobal = party(replace,allNotWordSymbolsRegexpGlobal(), ''); 

आइए देखें पूरा कोड:

 //    -       const allNotWordSymbolsRegexpGlobal = () => /[\.,\/#!$%\^&\*;:{}=\-_~()?\s]/g; const replace = (regexp, replacement, str) => str.replace(regexp, replacement); const toLowerCase = str => str.toLowerCase(); const stringReverse = str => str.split('').reverse().join(''); const isStringsEqual = (strA, strB) => strA === strB; //       const testString = '    '; //           -    rambda.js const compose = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x); const curry = fn => (...args) => { if (fn.length > args.length) { const f = fn.bind(null, ...args); return curry(f); } else { return fn(...args) } } const party = (fn, ...args) => (...rest) => fn(...args.concat(rest)); //       const replaceAllNotWordSymbolsToEmpltyGlobal = party(replace,allNotWordSymbolsRegexpGlobal(), ''); const processFormPalindrom = compose( replaceAllNotWordSymbolsToEmpltyGlobal, toLowerCase, stringReverse ); const processFormTestString = compose( replaceAllNotWordSymbolsToEmpltyGlobal, toLowerCase, ); const checkPalindrom = testString => isStringsEqual(processFormPalindrom(testString), processFormTestString(testString)); 

यह बहुत अच्छा लग रहा है, लेकिन क्या होगा अगर यह हमारे लिए एक स्ट्रिंग नहीं है, लेकिन एक सरणी आएगी? इसलिए, हम एक और फ़ंक्शन जोड़ते हैं:

 const map = fn => (...args) => args.map(fn); 

अब यदि हमारे पास परीक्षण के लिए एक सरणी है, तो:

 const palindroms = ['    ','   ','   '. ' '] map(checkPalindrom )(...palindroms ); // [true, true, true, false]   

इस प्रकार हमने फीचर सेट लिखकर कार्य को हल किया। लेखन कोड की व्यर्थ शैली पर ध्यान दें - यह कार्यात्मक शुद्धता का लिटमस परीक्षण है।

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

कार्यात्मक पुस्तकालयों जैसे ramda.js में रचना और पाइप कार्य हैं। कम्पोज़िशन एल्गोरिथ्म को दाएँ से बाएँ, और पाइप से बाएँ से दाएँ लिखें। हमारे रचना समारोह रम्दा से पाइप का एक एनालॉग है। पुस्तकालय में दो अलग-अलग रचना कार्य हैं रचना दाएं से बाएं और बाएं से दाएं कार्यात्मक प्रोग्रामिंग के दो अलग-अलग अनुबंध हैं। यदि पाठकों में से एक को एक लेख मिलता है जो एफपी के सभी मौजूदा अनुबंधों का वर्णन करता है, तो इसे टिप्पणियों में साझा करें, मैं इसे खुशी के साथ पढ़ूंगा और टिप्पणी पर एक प्लस लगाऊंगा!

किसी फ़ंक्शन के औपचारिक मापदंडों की संख्या को एरिटी कहा जाता है। यह चरण परिवर्तन के सिद्धांत के दृष्टिकोण से भी एक महत्वपूर्ण परिभाषा है।

निष्कर्ष

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

मैंने कोड में कार्यात्मक शुद्धता प्राप्त करने के अपने तर्क को स्पष्ट करने के लिए जानबूझकर कथन - छद्म कोडरेव का तरीका चुना।

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

इन पंक्तियों की प्रक्रियाओं में दोहराव से छुटकारा पाना भी अच्छा होगा:

  replaceAllNotWordSymbolsToEmpltyGlobal, toLowerCase, 

सामान्य तौर पर, कोड में लगातार सुधार करना संभव और आवश्यक है!

भविष्य के लेख तक।