जावास्क्रिप्ट में कार्यात्मक प्रोग्रामिंग के सिद्धांत

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



यहां हम कार्यात्मक प्रोग्रामिंग और इसके कुछ महत्वपूर्ण सिद्धांतों के बारे में बात करते हैं। यह सभी जावास्क्रिप्ट कोड के कई उदाहरणों से स्पष्ट होगा।

कार्यात्मक प्रोग्रामिंग क्या है?

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

अब, उदाहरण के माध्यम से, हम कार्यात्मक प्रोग्रामिंग के कुछ विचारों का विश्लेषण करेंगे।

शुद्ध कार्य

शुद्ध कार्य पहली मौलिक अवधारणा है जिसे कार्यात्मक प्रोग्रामिंग के सार को समझने के लिए अध्ययन करने की आवश्यकता है।

"शुद्ध कार्य" क्या है? क्या एक समारोह "स्वच्छ" बनाता है? एक शुद्ध कार्य निम्नलिखित आवश्यकताओं को पूरा करना चाहिए:

• यह हमेशा लौटता है, जब उसी तर्क को पास करते हैं, तो वही परिणाम (ऐसे कार्यों को नियतात्मक भी कहा जाता है)।
• इस तरह के फ़ंक्शन के साइड इफेक्ट नहीं होते हैं।

शुद्ध कार्यों की पहली संपत्ति पर विचार करें, अर्थात् तथ्य यह है कि वे, जब उन पर एक ही तर्क पारित करते हैं, तो हमेशा एक ही परिणाम लौटाते हैं।

▍ फ़ंक्शन तर्क और वापसी मान

कल्पना करें कि हमें एक फ़ंक्शन बनाने की आवश्यकता है जो एक सर्कल के क्षेत्र की गणना करता है। एक फ़ंक्शन जो शुद्ध नहीं होता है, एक पैरामीटर के रूप में, सर्कल ( radius ) की radius , जिसके बाद वह अभिव्यक्ति radius * radius * PI की गणना का मान लौटाएगा:

 const PI = 3.14; function calculateArea(radius) { return radius * radius * PI; } calculateArea(10); //  314 

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

अब कल्पना करें कि कुछ गणितज्ञ इस निष्कर्ष पर पहुंचे कि निरंतर PI का मान 42 नंबर होना चाहिए, क्योंकि इस स्थिरांक का मान बदल गया था।

अब एक फ़ंक्शन जो शुद्ध नहीं है, जब इसे उसी इनपुट मान से पारित किया जाता है, तो संख्या 10 , मान 10 * 10 * 42 = 4200 वापस कर देगा। यह पता चला है कि यहां पिछले उदाहरण के समान है, radius पैरामीटर का मान, फ़ंक्शन एक अलग परिणाम देता है। चलो इसे ठीक करें:

 const PI = 3.14; function calculateArea(radius, pi) { return radius * radius * pi; } calculateArea(10, PI); //  314 

अब जब इस फ़ंक्शन को कॉल करते हैं, तो हम हमेशा इसके लिए तर्क pi । नतीजतन, फ़ंक्शन केवल उसी के साथ काम करेगा जो वैश्विक संस्थाओं का सहारा लिए बिना, जब इसे पास किया जाता है। यदि हम इस फ़ंक्शन के व्यवहार का विश्लेषण करते हैं, तो हम निम्नलिखित निष्कर्ष पर आ सकते हैं:

• यदि फ़ंक्शन radius के तर्क को 10 बराबर और तर्क pi को 3.14 बराबर पास करते हैं, तो यह हमेशा एक ही परिणाम लौटाएगा - 314 ।
• जब 10 radius तर्क और 42 pi के साथ कहा जाता है, तो यह हमेशा 4200 लौटाएगा।

फाइलें पढ़ना

यदि हमारा फ़ंक्शन फ़ाइलों को पढ़ता है, तो यह साफ नहीं होगा। तथ्य यह है कि फाइलों की सामग्री बदल सकती है।

 function charactersCounter(text) { return `Character count: ${text.length}`; } function analyzeFile(filename) { let fileContent = open(filename); return charactersCounter(fileContent); } 

यादृच्छिक संख्या पीढ़ी

कोई भी फ़ंक्शन जो एक यादृच्छिक संख्या जनरेटर पर निर्भर करता है, शुद्ध नहीं हो सकता है।

 function yearEndEvaluation() { if (Math.random() > 0.5) {   return "You get a raise!"; } else {   return "Better luck next year!"; } } 

अब बात करते हैं साइड इफेक्ट्स की।

▍ दुष्प्रभाव

एक पक्ष प्रभाव का एक उदाहरण जो तब होता है जब किसी फ़ंक्शन को कहा जाता है, संदर्भ द्वारा फ़ंक्शन के लिए पारित वैश्विक चर या तर्कों का संशोधन है।

मान लें कि हमें एक ऐसा फ़ंक्शन बनाना है जो 1 से पूर्णांक और वेतन वृद्धि लेता है। यहां एक समान विचार के कार्यान्वयन के बारे में बताया गया है:

 let counter = 1; function increaseCounter(value) { counter = value + 1; } increaseCounter(counter); console.log(counter); // 2 

एक वैश्विक चर counter । हमारा फ़ंक्शन, जो शुद्ध नहीं है, इस मान को एक तर्क के रूप में प्राप्त करता है और इसे अधिलेखित करता है, एक को इसके पिछले मूल्य में जोड़ता है।

वैश्विक चर बदल रहा है, कार्यात्मक प्रोग्रामिंग के समान स्वागत योग्य नहीं है।

हमारे मामले में, वैश्विक चर का मूल्य संशोधित है। इन शर्तों के तहत कैसे बढ़ें मुठभेड़ increaseCounter() फ़ंक्शन को साफ करें? वास्तव में, यह बहुत सरल है:

 let counter = 1; function increaseCounter(value) { return value + 1; } increaseCounter(counter); // 2 console.log(counter); // 1 

जैसा कि आप देख सकते हैं, फ़ंक्शन 2 लौटता है, लेकिन वैश्विक चर counter का मूल्य नहीं बदलता है। यहां हम यह निष्कर्ष निकाल सकते हैं कि फ़ंक्शन किसी भी परिवर्तन नहीं करते हुए, उसके पास दिए गए मान को 1 बढ़ा देता है।

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

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

। शुद्ध कार्यों की शक्ति

शुद्ध कार्यों की ताकत के बीच तथ्य यह है कि कोड का उपयोग करके उन्हें परीक्षण करना आसान है। विशेष रूप से, आपको कोई स्टब ऑब्जेक्ट बनाने की आवश्यकता नहीं है। यह विभिन्न संदर्भों में शुद्ध कार्यों की इकाई परीक्षण की अनुमति देता है:

• यदि पैरामीटर A फ़ंक्शन में जाता है, तो B का रिटर्न मान अपेक्षित है।
• यदि पैरामीटर C को फ़ंक्शन में पास किया जाता है, तो D का रिटर्न मान अपेक्षित है।

इस विचार के एक सरल उदाहरण के रूप में, हम एक फ़ंक्शन दे सकते हैं जो संख्याओं की एक सरणी लेता है, और यह अपेक्षा की जाती है कि यह इस सरणी के प्रत्येक संख्या में वृद्धि करेगा, परिणामों के साथ एक नया सरणी लौटाएगा:

 let list = [1, 2, 3, 4, 5]; function incrementNumbers(list) { return list.map(number => number + 1); } 

यहां हम फ़ंक्शन के लिए संख्याओं की एक सरणी पास करते हैं, जिसके बाद हम map() सरणी विधि का उपयोग करते हैं, जो हमें सरणी के प्रत्येक तत्व को संशोधित करने की अनुमति देता है और फ़ंक्शन द्वारा लौटाए गए नए सरणी बनाता है। हम इसे एक list सरणी पास करके फ़ंक्शन कहते हैं:

 incrementNumbers(list); //  [2, 3, 4, 5, 6] 

इस फ़ंक्शन से यह उम्मीद की जाती है कि, फॉर्म [1, 2, 3, 4, 5] को स्वीकार करते हुए, यह एक नया एरे [2, 3, 4, 5, 6] लौटाएगा। इस तरह यह काम करता है।

Immutabelnost

एक निश्चित इकाई की प्रतिरक्षा को इस तथ्य के रूप में वर्णित किया जा सकता है कि यह समय के साथ नहीं बदलता है, या इस इकाई को बदलने की असंभवता के रूप में।

यदि वे एक अपरिवर्तनीय वस्तु को बदलने की कोशिश करते हैं, तो यह सफल नहीं होगा। इसके बजाय, आपको एक नया ऑब्जेक्ट बनाने की आवश्यकता होगी जिसमें नए मान होंगे।

उदाहरण के लिए, जावास्क्रिप्ट अक्सर लूप के for उपयोग करता है। उनके काम के क्रम में, जैसा कि नीचे दिखाया गया है, परिवर्तनशील चर का उपयोग किया जाता है:

 var values = [1, 2, 3, 4, 5]; var sumOfValues = 0; for (var i = 0; i < values.length; i++) { sumOfValues += values[i]; } sumOfValues // 15 

लूप के प्रत्येक पुनरावृत्ति पर, वैरिएबल i का मान और ग्लोबल वैरिएबल का मान (इसे प्रोग्राम की स्थिति माना जा सकता है) sumOfValues । संस्थाओं की अपरिहार्यता को बनाए रखने के लिए ऐसी स्थिति में कैसे? उत्तर पुनरावृत्ति का उपयोग करने में निहित है।

 let list = [1, 2, 3, 4, 5]; let accumulator = 0; function sum(list, accumulator) { if (list.length == 0) {   return accumulator; } return sum(list.slice(1), accumulator + list[0]); } sum(list, accumulator); // 15 list; // [1, 2, 3, 4, 5] accumulator; // 0 

एक फ़ंक्शन sum() , जो संख्याओं की एक सरणी लेता है। यह फ़ंक्शन सरणी खाली होने तक खुद को कॉल करता है (यह हमारे पुनरावर्ती एल्गोरिदम का मूल मामला है )। प्रत्येक ऐसे "पुनरावृत्ति" पर, हम accumulator फ़ंक्शन के पैरामीटर के लिए वैश्विक चर accumulator को प्रभावित किए बिना, सरणी के तत्वों में से एक का मूल्य जोड़ते हैं। इस मामले में, वैश्विक चर list और accumulator अपरिवर्तित रहते हैं, फ़ंक्शन कॉल के पहले और बाद में समान मान संग्रहीत किए जाते हैं।

यह ध्यान दिया जाना चाहिए कि इस तरह के एल्गोरिदम को लागू करने के लिए, आप reduce सरणी विधि का उपयोग कर सकते हैं। हम इस बारे में नीचे बात करेंगे।

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

यदि हम रूबी का उपयोग करके और OOP के सिद्धांतों का उपयोग करके इस समस्या को हल करते हैं, तो हम पहले एक वर्ग बनाएंगे, कहते हैं, इसे UrlSlugify कहते हैं, और फिर इस वर्ग के लिए एक विधि slugify! जिसका उपयोग स्ट्रिंग को परिवर्तित करने के लिए किया जाता है।

 class UrlSlugify attr_reader :text def initialize(text)   @text = text end def slugify!   text.downcase!   text.strip!   text.gsub!(' ', '-') end end UrlSlugify.new(' I will be a url slug   ').slugify! # "i-will-be-a-url-slug" 

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

हालाँकि, इस परिवर्तन के दौरान, प्रोग्राम स्टेट का एक म्यूटेशन होता है।

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

 let string = " I will be a url slug   "; function slugify(string) { return string.toLowerCase()   .trim()   .split(" ")   .join("-"); } slugify(string); // i-will-be-a-url-slug 

यहां हम निम्नलिखित कार्यों का उपयोग करते हैं, मानक स्ट्रिंग और सरणी विधियों द्वारा जावास्क्रिप्ट में प्रतिनिधित्व किया गया है:

• toLowerCase : स्ट्रिंग वर्णों को कम करने के लिए परिवर्तित करता है।
• trim : एक लाइन की शुरुआत और अंत से व्हाट्सएप को हटा देता है।
• split : एक स्ट्रिंग को भागों में split करता है, शब्दों को एक सरणी में रिक्त स्थान से अलग करता है।
• join : शब्दों के साथ एक सरणी पर आधारित डैश द्वारा अलग किए गए शब्दों के साथ एक स्ट्रिंग बनाता है।

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

लिंक पारदर्शिता

एक फ़ंक्शन square() बनाएं जो किसी संख्या को उसी संख्या से गुणा करने का परिणाम देता है:

 function square(n) { return n * n; } 

यह एक शुद्ध फ़ंक्शन है जो हमेशा एक ही इनपुट मान के लिए, समान आउटपुट मान लौटाएगा।

 square(2); // 4 square(2); // 4 square(2); // 4 // ... 

उदाहरण के लिए, चाहे कितने नंबर 2 पास हो जाएं, यह फ़ंक्शन हमेशा नंबर 4 लौटाएगा। नतीजतन, यह पता चलता है कि फॉर्म square(2) एक कॉल को नंबर 4 बदला जा सकता है। इसका मतलब है कि हमारे फ़ंक्शन में संदर्भात्मक पारदर्शिता की संपत्ति है।

सामान्य तौर पर, हम यह कह सकते हैं कि यदि कोई फ़ंक्शन अपरिवर्तित रूप से उसी इनपुट मानों के लिए एक ही परिणाम देता है, तो उसके पास संदर्भात्मक पारदर्शिता है।

EntialPure फ़ंक्शन + अपरिवर्तनीय डेटा = संदर्भात्मक पारदर्शिता

इस खंड के शीर्षक में सामने रखे गए विचार का उपयोग करके, आप फ़ंक्शन को याद कर सकते हैं। मान लीजिए कि हमारे पास एक फ़ंक्शन है:

 function sum(a, b) { return a + b; } 

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

 sum(3, sum(5, 8)); 

sum(5, 8) कॉल करने पर हमेशा 13 । इसलिए, उपरोक्त कॉल को निम्नानुसार फिर से लिखा जा सकता है:

 sum(3, 13); 

यह अभिव्यक्ति, बदले में, हमेशा 16 देती है। नतीजतन, इसे एक संख्यात्मक स्थिरांक और ज्ञापन द्वारा प्रतिस्थापित किया जा सकता है।

प्रथम श्रेणी की वस्तुओं के रूप में कार्य

पहली कक्षा की वस्तुओं के रूप में कार्यों को मानने का विचार यह है कि ऐसे कार्यों को मूल्यों के रूप में माना जा सकता है और डेटा के रूप में उनके साथ काम किया जा सकता है। कार्यों की निम्नलिखित विशेषताएं प्रतिष्ठित की जा सकती हैं:

• फ़ंक्शंस के संदर्भों को स्थिरांक और चर में संग्रहीत किया जा सकता है और उनके माध्यम से फ़ंक्शंस तक पहुंच हो सकती है।
• कार्यों को अन्य कार्यों के लिए मापदंडों के रूप में पारित किया जा सकता है।
• अन्य कार्यों से कार्य लौटाए जा सकते हैं।

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

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

 function doubleSum(a, b) { return (a + b) * 2; } 

अब हम एक ऐसा फंक्शन लिखते हैं, जो इसमें दिए गए पहले संख्यात्मक मान से दूसरे को घटाता है, जो हुआ उसे 2 गुणा करता है, और परिकलित मान को लौटाता है:

 function doubleSubtraction(a, b) { return (a - b) * 2; } 

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

 function sum(a, b) { return a + b; } function subtraction(a, b) { return a - b; } function doubleOperator(f, a, b) { return f(a, b) * 2; } doubleOperator(sum, 3, 1); // 8 doubleOperator(subtraction, 3, 1); // 4 

जैसा कि आप देख सकते हैं, अब doubleOperator() फ़ंक्शन में एक पैरामीटर f , और जो फ़ंक्शन इसका प्रतिनिधित्व करता है वह पैरामीटर a और b को संसाधित करने के लिए उपयोग किया जाता है। doubleOperator() फ़ंक्शन के लिए दिया गया sum() और substraction() फ़ंक्शन, वास्तव में, आप doubleOperator() फ़ंक्शन के व्यवहार को नियंत्रित करने की अनुमति देते हैं, इसे उनमें लागू तर्क के अनुसार बदलते हैं।

उच्च आदेश कार्य

उच्च-क्रम के कार्यों की बात करते हुए, हमारा मतलब उन कार्यों से है जो निम्न विशेषताओं में से एक हैं।

• एक फ़ंक्शन दूसरे फ़ंक्शन को एक तर्क के रूप में लेता है (ऐसे कई कार्य हो सकते हैं)।
• फ़ंक्शन अपने कार्य के परिणाम के रूप में एक और फ़ंक्शन देता है।

आप पहले से ही मानक JS सरणी विधियों filter() , map() और reduce() परिचित हो सकते हैं। आइए उनके बारे में बात करते हैं।

▍ फ़िल्टरिंग सरणियाँ और फ़िल्टर () विधि

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

कल्पना कीजिए कि हमारे पास एक पूर्णांक है और हम इसे एक नया सरणी प्राप्त करके फ़िल्टर करना चाहते हैं जिसमें मूल सरणी से केवल संख्याएँ हैं।

इंपीरियल दृष्टिकोण

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

• नए तत्वों के लिए एक खाली सरणी बनाएं (इसे evenNumbers कॉल करें)।
• पूर्णांक के मूल सरणी पर फेरबदल करें (चलो इसे numbers कहते हैं)।
• सम संख्या सरणी evenNumbers पाए गए सम संख्याओं को समान संख्या में रखें।

यहाँ इस एल्गोरिथ्म का कार्यान्वयन कैसा दिखता है:

 var numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var evenNumbers = []; for (var i = 0; i < numbers.length; i++) { if (numbers[i] % 2 == 0) {   evenNumbers.push(numbers[i]); } } console.log(evenNumbers); // (6) [0, 2, 4, 6, 8, 10] 

इसके अलावा, हम एक फ़ंक्शन लिख सकते हैं (चलो इसे even() कॉल करें even() , यदि संख्या समान है, तो true , और यदि यह विषम है, तो false , और फिर इसे filter() सरणी विधि में पास करें, जो इसके साथ जांच करके, सरणी के प्रत्येक तत्व को दिखाता है। , एक नई सरणी बनाएगा जिसमें केवल संख्याएँ होंगी:

 function even(number) { return number % 2 == 0; } let listOfNumbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; listOfNumbers.filter(even); // [0, 2, 4, 6, 8, 10] 

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

जावास्क्रिप्ट में इस समस्या का एक अनिवार्य समाधान इस तरह दिख सकता है:

 var filterArray = function(x, coll) { var resultArray = []; for (var i = 0; i < coll.length; i++) {   if (coll[i] < x) {     resultArray.push(coll[i]);   } } return resultArray; } console.log(filterArray(3, [10, 9, 8, 2, 7, 5, 1, 3, 0])); // (3) [2, 1, 0] 

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

घोषणात्मक दृष्टिकोण

इस समस्या को हल करने के लिए एक घोषणात्मक दृष्टिकोण पर स्विच कैसे करें और filter() विधि का एक समान उपयोग, जो एक उच्च-क्रम फ़ंक्शन है? उदाहरण के लिए, यह इस तरह दिख सकता है:

 function smaller(number) { return number < this; } function filterArray(x, listOfNumbers) { return listOfNumbers.filter(smaller, x); } let numbers = [10, 9, 8, 2, 7, 5, 1, 3, 0]; filterArray(3, numbers); // [2, 1, 0] 

आपको इस उदाहरण में smaller() फ़ंक्शन में इस this का उपयोग करना असामान्य लग सकता है, लेकिन यहां कुछ भी जटिल नहीं है। this filter() विधि का दूसरा तर्क है। हमारे उदाहरण में, यह filterArray() के x पैरामीटर द्वारा दर्शाया गया नंबर 3 । यह संख्या इसी से इंगित होती है।

उसी दृष्टिकोण का उपयोग किया जा सकता है यदि सरणी में ऐसी इकाइयाँ हों जिनमें एक जटिल संरचना होती है, उदाहरण के लिए, ऑब्जेक्ट। मान लें कि हमारे पास एक सरणी है जिसमें वस्तुओं का name संपत्ति द्वारा दर्शाए गए लोगों के name हैं, और इन लोगों की age संपत्ति के प्रतिनिधित्व के बारे में जानकारी है। यहां एक सरणी दिखती है:

 let people = [ { name: "TK", age: 26 }, { name: "Kaio", age: 10 }, { name: "Kazumi", age: 30 } ]; 

हम इस सरणी को केवल उन वस्तुओं को चुनकर फ़िल्टर करना चाहते हैं, जो ऐसे लोग हैं जिनकी उम्र 21 वर्ष से अधिक हो गई है। इस समस्या को हल करने का तरीका यहां दिया गया है:

 function olderThan21(person) { return person.age > 21; } function overAge(people) { return people.filter(olderThan21); } overAge(people); // [{ name: 'TK', age: 26 }, { name: 'Kazumi', age: 30 }] 

यहाँ हम लोगों का प्रतिनिधित्व करने वाली वस्तुओं के साथ एक सरणी है। हम इस सरणी के तत्वों को olderThan21() फ़ंक्शन का उपयोग करके olderThan21() । इस मामले में, जाँच करते समय, हम प्रत्येक तत्व की age संपत्ति का उल्लेख करते हैं, यह जाँचते हुए कि क्या इस संपत्ति का मूल्य 21 से अधिक है। हम इस फ़ंक्शन को filter() विधि में पास करते हैं, जो सरणी को फ़िल्टर करता है।

Array प्रसंस्करण तत्व तत्व और नक्शा () विधि

सरणी तत्वों को परिवर्तित करने के लिए map() विधि का उपयोग किया जाता है। वह एरे के प्रत्येक तत्व को दिए गए फंक्शन को लागू करता है, और फिर बदले हुए तत्वों से मिलकर एक नया एरे बनाता है।

आइए उन people साथ प्रयोग जारी रखें जिन्हें आप पहले से जानते हैं। अब हम इस सरणी को age वस्तुओं की संपत्ति के आधार पर फ़िल्टर नहीं करने जा रहे हैं। हमें इसके आधार पर फॉर्म की पंक्तियों की एक सूची तैयार करनी होगी जो कि TK is 26 years old । इस दृष्टिकोण में, वे पंक्तियाँ जिनमें तत्व बदल जाते हैं, उनका निर्माण टेम्पलेट p.name is p.age years old अनुसार किया जाएगा p.name is p.age years old , जहाँ p.age और p.age people सरणी के तत्वों के संगत गुणों के मान हैं।

जावास्क्रिप्ट में इस समस्या को हल करने के लिए एक जरूरी तरीका इस तरह दिखता है:

 var people = [ { name: "TK", age: 26 }, { name: "Kaio", age: 10 }, { name: "Kazumi", age: 30 } ]; var peopleSentences = []; for (var i = 0; i < people.length; i++) { var sentence = people[i].name + " is " + people[i].age + " years old"; peopleSentences.push(sentence); } console.log(peopleSentences); // ['TK is 26 years old', 'Kaio is 10 years old', 'Kazumi is 30 years old'] 

यदि आप एक घोषणात्मक दृष्टिकोण का सहारा लेते हैं, तो आपको निम्नलिखित मिलते हैं:

 function makeSentence(person) { return `${person.name} is ${person.age} years old`; } function peopleSentences(people) { return people.map(makeSentence); } peopleSentences(people); // ['TK is 26 years old', 'Kaio is 10 years old', 'Kazumi is 30 years old'] 

तथ्य के रूप में, यहां मुख्य विचार यह है कि आपको मूल सरणी के प्रत्येक तत्व के साथ कुछ करने की आवश्यकता है, और फिर इसे एक नए सरणी में रखें।

यहां हैकर रैंक के साथ एक और कार्य है, जो सूची को अपडेट करने के लिए समर्पित है। अर्थात्, हम एक मौजूदा संख्यात्मक सरणी के तत्वों के मूल्यों को उनके पूर्ण मूल्यों में बदलने के बारे में बात कर रहे हैं। इसलिए, उदाहरण के लिए, जब एक सरणी [1, 2, 3, -4, 5] प्रसंस्करण किया जाता है [1, 2, 3, -4, 5] यह -4 का निरपेक्ष मान [1, 2, 3, 4, 5] क्योंकि यह [1, 2, 3, 4, 5] का रूप ले लेगा।

इस समस्या के लिए एक सरल समाधान का एक उदाहरण है, जब हम एक सरणी पर पुनरावृति करते हैं और उसके तत्वों के मूल्यों को उनके पूर्ण मूल्यों में बदलते हैं।

 var values = [1, 2, 3, -4, 5]; for (var i = 0; i < values.length; i++) { values[i] = Math.abs(values[i]); } console.log(values); // [1, 2, 3, 4, 5] 

यहां, सरणी के तत्वों के मूल्यों को परिवर्तित करने के लिए, Math.abs() पद्धति का उपयोग किया जाता है, परिवर्तित तत्व उसी स्थान पर लिखे जाते हैं जहां वे रूपांतरण से पहले थे।

.

, , , . . , , , .

, , map() . ?

, abs() , , .

 Math.abs(-1); // 1 Math.abs(1); // 1 Math.abs(-2); // 2 Math.abs(2); // 2 

, , .

, , Math.abs() map() . , ? map() . :

 let values = [1, 2, 3, -4, 5]; function updateListMap(values) { return values.map(Math.abs); } updateListMap(values); // [1, 2, 3, 4, 5] 

, , , , , .

▍ reduce()

reduce() .

. , -. Product 1 , Product 2 , Product 3 Product 4 . .

, . उदाहरण के लिए, यह इस तरह दिख सकता है:

 var orders = [ { productTitle: "Product 1", amount: 10 }, { productTitle: "Product 2", amount: 30 }, { productTitle: "Product 3", amount: 20 }, { productTitle: "Product 4", amount: 60 } ]; var totalAmount = 0; for (var i = 0; i < orders.length; i++) { totalAmount += orders[i].amount; } console.log(totalAmount); // 120 

reduce() , ( sumAmount() ), , reduce() :

 let shoppingCart = [ { productTitle: "Product 1", amount: 10 }, { productTitle: "Product 2", amount: 30 }, { productTitle: "Product 3", amount: 20 }, { productTitle: "Product 4", amount: 60 } ]; const sumAmount = (currentTotalAmount, order) => currentTotalAmount + order.amount; function getTotalAmount(shoppingCart) { return shoppingCart.reduce(sumAmount, 0); } getTotalAmount(shoppingCart); // 120 

shoppingCart , , sumAmount() , ( order , amount ), — currentTotalAmount .

reduce() , getTotalAmount() , sumAmount() , 0 .

map() reduce() . «»? , map() shoppingCart , amount , reduce() sumAmount() . :

 const getAmount = (order) => order.amount; const sumAmount = (acc, amount) => acc + amount; function getTotalAmount(shoppingCart) { return shoppingCart   .map(getAmount)   .reduce(sumAmount, 0); } getTotalAmount(shoppingCart); // 120 

getAmount() amount . map() , , , [10, 30, 20, 60] . , reduce() , .

▍ filter(), map() reduce()

, , filter() , map() reduce() . , , .

-. , :

 let shoppingCart = [ { productTitle: "Functional Programming", type: "books", amount: 10 }, { productTitle: "Kindle", type: "eletronics", amount: 30 }, { productTitle: "Shoes", type: "fashion", amount: 20 }, { productTitle: "Clean Code", type: "books", amount: 60 } ] 

. :

• type , , books .
• , .
• .

, :

 let shoppingCart = [ { productTitle: "Functional Programming", type: "books", amount: 10 }, { productTitle: "Kindle", type: "eletronics", amount: 30 }, { productTitle: "Shoes", type: "fashion", amount: 20 }, { productTitle: "Clean Code", type: "books", amount: 60 } ] const byBooks = (order) => order.type == "books"; const getAmount = (order) => order.amount; const sumAmount = (acc, amount) => acc + amount; function getTotalAmount(shoppingCart) { return shoppingCart   .filter(byBooks)   .map(getAmount)   .reduce(sumAmount, 0); } getTotalAmount(shoppingCart); // 70 

परिणाम

JavaScript-. , .

प्रिय पाठकों! ?