क्रैकिंग रिड्यूस कॉन्सेप्ट सिर्फ 10 मिनट में

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

विकिपीडिया में, इसके कई नाम हैं।

कम करें
तह
संचित
कुल
कम्प्रेस

यह एक फ़ंक्शन है जो किसी भी डेटा प्रकार में एक सूची को तह करता है। यह सब एक मूल्य में एक संरचना को तोड़ने के बारे में है। यह एक बॉक्स को फोल्ड करने जैसा है! कम करने के साथ, आप सभी को जोड़कर एक सरणी [1,2,3,4,5] को संख्या 15 में बदल सकते हैं।

यह पूर्व में कैसे किया गया था?

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

const add = (x, y) => x + y; const numbers = [1, 2, 3, 4, 5]; let total = 0; for (let i = 0; i < numbers.length; i++) { total = add(total, numbers[i]); } console.log(total); 

हालाँकि, फ़ंक्शन को कम करने के लिए, आपको "फ़ंक्शन जोड़ने" के साथ-साथ संभाल करने के लिए एक लूप की आवश्यकता है। कोड इस प्रकार होगा:

 const add = (x, y) => x + y; const numbers = [1, 2, 3, 4, 5]; numbers.reduce(add); 

देखें, यह इस तरह से आसान कोडिंग है!

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

-> फ़िल्टरिंग सूची
-> रूपांतरण सूची
-> डेटा प्रकारों में सूचियों को परिवर्तित करना। स्ट्रिंग, बूलियन, संख्या, वस्तु

उपरोक्त चुनौती को उपकरण फ़िल्टर, मानचित्र और कम करने के साथ आसानी से नियंत्रित किया जा सकता है।

Array.filter न्यायाधीशों की सूची

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

 const isEven = (x) => x % 2 === 0; 

अब, इसे पूरी सूची के विरुद्ध लागू करने के लिए फ़िल्टर में प्लग करें।

 const numbers = [1, 2, 3, 4, 5]; numbers.filter(isEven); 

Array.map सूचियों को रूपांतरित करता है

सूचियों को अन्य सूचियों में परिवर्तित करना संक्षेप में फ्रंट-एंड डेवलपमेंट है। इसलिए, मानचित्र में आपकी सूची के बहुत काम शामिल हैं।

मान लीजिए कि हमारा एप्लिकेशन उपयोगकर्ताओं की सूची के लिए एपीआई कॉल करता है, और हमें स्क्रीन पर प्रत्येक उपयोगकर्ता का नाम दिखाना होगा। बस एक फ़ंक्शन बनाएं जो उपयोगकर्ता के नाम को लौटाता है।

 const getUserName = (user) => user.name; 

अब, इसे उपयोगकर्ताओं की पूरी सूची के विरुद्ध चलाने के लिए मानचित्र में प्लग करें।

 users.map(getUserName) 

Array.reduce यह आपके लिए कर सकता है

Array.reduce दो मापदंडों का उपयोग करता है

1) एक प्रारंभिक मूल्य (जो वैकल्पिक है)

यदि आप प्रारंभिक मूल्य की आपूर्ति नहीं करते हैं, तो सूची के पहले तत्व में फ़ंक्शन डिफॉल्ट को कम करें।

सम संख्याओं के लिए, आप लिखेंगे:

 [1, 2, 3].reduce((total, current) => total + current);/source> In case, you give an initial value of zero, you will use this code: <source lang="markdown"> [{ age: 1 }, { age: 2 }, { age: 3 }] .reduce((total, obj) => total + obj.age, 0); 

2) reducer

जब सूची में छोरों को कम करते हैं, तो यह reducer के दो मापदंडों के नीचे होता है:

-> वर्तमान मूल्य: वर्तमान मूल्य स्व-व्याख्यात्मक है, जैसे कि जब आप नियमित लूप में मैट्रिक्स [i] का उपयोग करते हैं। हालाँकि, संचायक एक कंप्यूटर शब्द है जो डरावना लगता है और वास्तव में सरल है।

-> संचयकर्ता: जब आप उपयोगकर्ताओं को ब्राउज़ कर रहे होते हैं, तो आप उनकी कुल आयु को कैसे ट्रैक करते हैं? इसे रखने के लिए आपको कुछ काउंटर चर की आवश्यकता होती है। वह संचयकर्ता है। यह अंतिम मूल्य है जो समाप्त होने पर कम हो जाएगा।

चक्र के प्रत्येक चरण पर, यह अंतिम संचायक और वर्तमान तत्व को इसके रेड्यूसर को खिलाता है। क्या reducer रिटर्न अगले संचायक बन जाता है। सूची समाप्त होने पर चक्र समाप्त हो जाता है और इसका एकल मूल्य कम हो जाता है।

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

चलो उपयोगकर्ताओं की आयु की गणना करने के लिए एक उदाहरण की मदद लेते हैं। उपयोगकर्ताओं की आयु 29.30, 31 और 32 मानें।

 const users = [ { name: 'Mariam', age: 29 }, { name: 'Kenstar', age: 30 }, { name: 'Saransh', age: 31 }, { name: 'Geoffie', age: 32 }, ]; 

दूसरी ओर, मानचित्र और फ़िल्टर केवल सरणियाँ लौटा सकते हैं, लेकिन हमें एक संख्या चाहिए!

 users.map(?); users.filter(?); 

यदि हमारे पास लूप होते तो हम केवल उपयोगकर्ताओं के माध्यम से जाते और एक काउंटर में उनकी उम्र को पूरा करते! हालांकि, फ़ंक्शन को कम करना आसान हो सकता है।

 users.reduce((total, currentUser) => total + currentUser.age, 0); 

अब, प्रत्येक चरण में कंसोल.लॉग का उपयोग करके ऊपर दिए गए हैंडल करने का सबसे आसान तरीका हो सकता है।

 const users = [ { name: 'Mariam', age: 29 }, { name: 'Kenstar', age: 30 }, { name: 'Saransh', age: 31 }, { name: 'Geoffie', age: 32 }, ]; const reducer = (total, currentUser) => { console.log('current total:', total); console.log('currentUser:', currentUser); // just for spacing console.log('\n'); return total + currentUser.age; } users.reduce(reducer, 0); 

यहाँ 6 चरणों में पूरे कोड को सारांशित करना:

-> सबसे पहले, कम समारोह और उसके 3 मापदंडों को परिभाषित करें।
-> प्रारंभिक-मूल्य प्रदान करके, संचायक को इनिशियलाइज़ करें। यह हर लूप को बदल देगा।
-> अब, दिए गए एरे पर लूपिंग शुरू करें।
-> उस चक्र के लिए सरणी के currentItem पर कब्जा।
-> यह संचायक और currentItem के साथ reducer को कॉल करने और इसे एक नए संचायक के रूप में सहेजने का समय है
-> अंत में, लूप समाप्त होने पर संचायक को बदल दिया जाता है और इसे वापस कर दिया जाता है।