कार्यात्मक जावास्क्रिप्ट: सरणी तत्वों और .reduce () विधि के अंकगणितीय माध्य को खोजने के पांच तरीके

सरणी पुनरावृत्ति विधियां "ड्रग्स शुरू करने" के समान हैं (ज़ाहिर है, वे ड्रग्स नहीं हैं; और मैं यह नहीं कह रहा हूं कि ड्रग्स अच्छे हैं; वे केवल भाषण का एक आंकड़ा हैं)। उनके कारण, कई लोग कार्यात्मक प्रोग्रामिंग पर "बैठ जाते हैं"। बात यह है कि वे अविश्वसनीय रूप से सुविधाजनक हैं। इसके अलावा, इन तरीकों में से अधिकांश को समझना बहुत आसान है। .map() और .filter() जैसे तरीके सिर्फ एक कॉलबैक तर्क को स्वीकार करते हैं और आपको सरल समस्याओं को हल करने की अनुमति देते हैं। लेकिन एक भावना है कि .reduce() विधि कई के लिए कुछ कठिनाइयों का कारण बनती है। इसे समझना थोड़ा और मुश्किल है।



मैंने पहले ही लिखा है कि मुझे क्यों लगता है कि .reduce() बहुत सारी समस्याएं पैदा करता है। यह आंशिक रूप से इस तथ्य के कारण है कि कई मैनुअल संख्याओं को संभालने के दौरान केवल .reduce() के उपयोग को प्रदर्शित करते हैं। इसलिए, मैंने लिखा है कि कितने कार्य जो अंकगणित संचालन का उपयोग नहीं करते हैं, .reduce() का उपयोग करके हल किया जा सकता है। लेकिन क्या होगा अगर आपको संख्याओं के साथ काम करने की आवश्यकता है?

.reduce() का एक विशिष्ट उपयोग किसी सरणी के तत्वों के अंकगणितीय माध्य की गणना की तरह दिखता है। पहली नज़र में, ऐसा लगता है कि इस कार्य में कुछ खास नहीं है। लेकिन वह इतनी सरल नहीं है। तथ्य यह है कि औसत की गणना करने से पहले, आपको निम्नलिखित संकेतक खोजने की आवश्यकता है:

1. सरणी तत्व मानों की कुल राशि।
2. व्यूह की लंबाई।

यह सब पता लगाना बहुत सरल है। और संख्यात्मक सरणियों के लिए औसत मूल्यों की गणना भी एक कठिन ऑपरेशन नहीं है। यहाँ एक प्रारंभिक उदाहरण है:

 function average(nums) {    return nums.reduce((a, b) => (a + b)) / nums.length; } 

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

इससे निपटने के लिए, हम प्रशिक्षण समस्या का समाधान करेंगे (यह फ्रीकोडकोड के साथ इस कार्य पर आधारित है)। हम इसे पांच अलग-अलग तरीकों से हल करेंगे। उनमें से प्रत्येक के अपने फायदे और नुकसान हैं। इस समस्या को हल करने के लिए इन पांच दृष्टिकोणों का विश्लेषण दिखाएगा कि जावास्क्रिप्ट कितना लचीला हो सकता है। और मुझे आशा है कि समाधानों का विश्लेषण आपको वास्तविक परियोजनाओं में उपयोग करने के लिए .reduce() पर विचार के लिए भोजन देगा।

कार्य अवलोकन

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

 const victorianSlang = [           term: 'doing the bear',        found: true,        popularity: 108,    },           term: 'katterzem',        found: false,        popularity: null,    },           term: 'bone shaker',        found: true,        popularity: 609,    },           term: 'smothering a parrot',        found: false,        popularity: null,    },           term: 'damfino',        found: true,        popularity: 232,    },           term: 'rain napper',        found: false,        popularity: null,    },           term: 'donkey's breakfast',        found: true,        popularity: 787,    },           term: 'rational costume',        found: true,        popularity: 513,    },           term: 'mind the grease',        found: true,        popularity: 154,    }, ]; 

इस एरे से भावों के लोकप्रियता अनुमान का औसत मूल्य ज्ञात करने के 5 तरीकों पर विचार करें।

1. .reduce () (अनिवार्य लूप) का उपयोग किए बिना किसी समस्या का समाधान

समस्या को हल करने के लिए हमारे पहले दृष्टिकोण में, .reduce() विधि का उपयोग नहीं किया जाएगा। यदि आप पहले सरणियों को पुनरावृत्त करने के तरीकों के पार नहीं आए हैं, तो मुझे उम्मीद है कि इस उदाहरण को पार्स करने से आपके लिए स्थिति थोड़ी स्पष्ट हो जाएगी।

 let popularitySum = 0; let itemsFound = 0; const len = victorianSlang.length; let item = null; for (let i = 0; i < len; i++) {    item = victorianSlang[i];    if (item.found) {        popularitySum = item.popularity + popularitySum;        itemsFound = itemsFound + 1;   } const averagePopularity = popularitySum / itemsFound; console.log("Average popularity:", averagePopularity); 

यदि आप जावास्क्रिप्ट से परिचित हैं, तो आप इस उदाहरण को आसानी से समझ पाएंगे। वास्तव में, निम्नलिखित यहाँ होता है:

1. हम वैरिएबल popularitySum और itemsFound शुरू करते हैं। पहला चर, popularitySum , अभिव्यक्ति की लोकप्रियता की समग्र रेटिंग संग्रहीत करता है। और दूसरा चर, itemsFound , (यह एक आश्चर्य की बात है) पाए जाने वाले भावों की संख्या को संग्रहीत करता है।
2. फिर हम निरंतर len और वैरिएबल item को इनिशियलाइज़ करते हैं, जो एरे को ट्रेस करते समय हमारे लिए उपयोगी होते हैं।
3. एक लूप के लिए, काउंटर i तब तक बढ़ा दिया जाता है जब तक कि इसका मान सरणी के अंतिम तत्व के सूचकांक मूल्य तक नहीं पहुंच जाता।
4. लूप के अंदर, हम उस ऐरे के तत्व को लेते हैं जिसे हम एक्सप्लोर करना चाहते हैं। हम victorianSlang[i] का उपयोग करते हुए तत्व का उपयोग करते हैं। निर्माण victorianSlang[i] निर्माण।
5. तब हमें पता चलता है कि क्या यह अभिव्यक्ति किताबों के संग्रह में पाई जाती है।
6. यदि पुस्तकों में अभिव्यक्ति होती है, तो हम इसकी लोकप्रियता रेटिंग का मान लेते हैं और परिवर्तनशील popularitySum के मान में जोड़ते हैं।
7. उसी समय, हम पाए गए अभिव्यक्तियों के काउंटर को भी बढ़ाते हैं - itemsFound ।
8. और अंत में, हम popularitySum को विभाजित करके औसत पाते हैं।

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

2. सरल समाधान # 1: .filter (), .map () और .reduce () का उपयोग करके राशि ढूंढना।

आइए, समस्या को हल करने के लिए सरणियों के तरीकों का उपयोग करने के पहले प्रयास से पहले, हम इसे छोटे भागों में तोड़ते हैं। अर्थात्, यहाँ हमें क्या करना है:

1. Google पुस्तक संग्रह में मौजूद अभिव्यक्तियों का प्रतिनिधित्व करने वाली वस्तुओं का चयन करें। यहां आप .filter() विधि का उपयोग कर सकते हैं।
2. वस्तुओं से भावों की लोकप्रियता का मूल्यांकन। इस उपशीर्षक को हल करने के लिए, .map() विधि उपयुक्त है।
3. रेटिंग के योग की गणना करें। यहाँ हम अपने पुराने मित्र की मदद का सहारा ले सकते हैं .reduce() ।
4. और अंत में, अनुमानों का औसत मूल्य ज्ञात करें।

यहाँ कोड में ऐसा दिखता है:

 //   // ---------------------------------------------------------------------------- function isFound(item) {    return item.found; }; function getPopularity(item) {    return item.popularity; } function addScores(runningTotal, popularity) {    return runningTotal + popularity; } //  // ---------------------------------------------------------------------------- //  ,      . const foundSlangTerms = victorianSlang.filter(isFound); //   ,   . const popularityScores = foundSlangTerms.map(getPopularity); //     .    ,    //   ,  reduce     ,  0. const scoresTotal = popularityScores.reduce(addScores, 0); //       . const averagePopularity = scoresTotal / popularityScores.length; console.log("Average popularity:", averagePopularity); 

addScore फ़ंक्शन और लाइन को .reduce() कहा जाता .reduce() , पर addScore नज़र डालें। ध्यान दें कि addScore दो मापदंडों को स्वीकार करता है। पहला, runningTotal , एक बैटरी के रूप में जाना जाता है। यह मूल्यों के योग को संग्रहीत करता है। जब हम सरणी पर पुनरावृति करते हैं और return निष्पादित करते return तो इसका मूल्य हर बार बदल जाता है। दूसरा पैरामीटर, popularity , उस सरणी का एक अलग तत्व है जिसे हम प्रसंस्करण कर रहे हैं। सरणी पर addScore की बहुत शुरुआत में, addScore में addScore को कभी भी निष्पादित नहीं किया गया है। इसका मतलब है कि runningTotal अभी तक स्वचालित रूप से सेट नहीं किया गया है। इसलिए, .reduce() को कॉल .reduce() , हम इस विधि को पास करते हैं, जिसे शुरू में ही runningTotal लिखने की आवश्यकता होती है। यह .reduce() लिए दिया गया दूसरा पैरामीटर है।

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

3. आसान समाधान # 2: कई बैटरियों का उपयोग करना

समाधान के पिछले संस्करण में, हमने मध्यवर्ती चर का एक पूरा गुच्छा बनाया। उदाहरण के लिए, foundSlangTerms और popularityScores । हमारे मामले में, ऐसा समाधान काफी स्वीकार्य है। लेकिन क्या होगा अगर हम खुद को कोड डिजाइन के बारे में अधिक जटिल लक्ष्य निर्धारित करते हैं? यह अच्छा होगा यदि हम कार्यक्रम में धाराप्रवाह इंटरफ़ेस डिजाइन पैटर्न का उपयोग कर सकते हैं। इस दृष्टिकोण के साथ, हम सभी फ़ंक्शंस की कॉल को चेन कर पाएंगे और इंटरमीडिएट वेरिएबल्स के बिना कर पाएंगे। हालांकि, एक समस्या हमें यहाँ इंतजार कर रही है। ध्यान दें कि हमें PopularScores.length का मूल्य प्राप्त करने की आवश्यकता है। यदि हम सब कुछ श्रृंखलाबद्ध करने जा रहे हैं, तो हमें सरणी में तत्वों की संख्या खोजने के कुछ अन्य तरीके की आवश्यकता है। औसत मान की गणना में सरणी में तत्वों की संख्या एक भाजक की भूमिका निभाती है। आइए देखें कि क्या हम समस्या को हल करने के लिए दृष्टिकोण को बदल सकते हैं ताकि एक श्रृंखला में विधि कॉल के संयोजन से सब कुछ किया जा सके। हम इसे दो मूल्यों पर नज़र रखने के द्वारा करेंगे, जब सरणी के तत्वों पर पुनरावृत्ति होगी, अर्थात, "दोहरी बैटरी" का उपयोग करना।

 //   // --------------------------------------------------------------------------------- function isFound(item) {    return item.found; }; function getPopularity(item) {    return item.popularity; } //    ,  return,   . function addScores({totalPopularity, itemCount}, popularity) {    return {        totalPopularity: totalPopularity + popularity,        itemCount:    itemCount + 1,    }; } //  // --------------------------------------------------------------------------------- const initialInfo  = {totalPopularity: 0, itemCount: 0}; const popularityInfo = victorianSlang.filter(isFound)    .map(getPopularity)    .reduce(addScores, initialInfo); //       . const {totalPopularity, itemCount} = popularityInfo; const averagePopularity = totalPopularity / itemCount; console.log("Average popularity:", averagePopularity); 

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

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

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

4. डॉट नोटेशन का उपयोग किए बिना कार्यों की संरचना

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

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

आप वैरिएबल का उपयोग किए बिना compose() फ़ंक्शन का उपयोग करके औसत की गणना करने के लिए एक फ़ंक्शन बना सकते हैं। हम इसे "ठीक-ठीक अंकन के उपयोग के बिना प्रोग्रामिंग" या "अंतर्निहित प्रोग्रामिंग" कहते हैं। ऐसे कार्यक्रमों को लिखने के लिए, आपको कई सहायक कार्यों की आवश्यकता होगी।

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

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

 //   // ---------------------------------------------------------------------------- const filter = p => a => a.filter(p); const map   = f => a => a.map(f); const prop  = k => x => x[k]; const reduce = r => i => a => a.reduce(r, i); const compose = (...fns) => (arg) => fns.reduceRight((arg, fn) => fn(arg), arg); //  -   "blackbird combinator". //     : https://jrsinclair.com/articles/2019/compose-js-functions-multiple-parameters/ const B1 = f => g => h => x => f(g(x))(h(x)); //  // ---------------------------------------------------------------------------- //   sum,    . const sum = reduce((a, i) => a + i)(0); //     . const length = a => a.length; //       . const div = a => b => a / b; //   compose()        . //    compose()     . const calcPopularity = compose(    B1(div)(sum)(length),    map(prop('popularity')),    filter(prop('found')), ); const averagePopularity = calcPopularity(victorianSlang); console.log("Average popularity:", averagePopularity); 

यदि यह सब कोड आपको पूरी तरह से बकवास लगता है - इसके बारे में चिंता न करें। मैंने इसे एक बौद्धिक अभ्यास के रूप में शामिल किया, न कि आपको परेशान करने के लिए।

इस मामले में, मुख्य कार्य compose() फ़ंक्शन में है। यदि आप इसकी सामग्री को नीचे से पढ़ते हैं, तो यह पता चलता है कि गणना इसके found तत्वों की संपत्ति द्वारा सरणी को फ़िल्टर करने से शुरू होती है। फिर हम map() का उपयोग करके popularity तत्व संपत्ति को पुनः प्राप्त करते हैं। उसके बाद हम तथाकथित " ब्लैकबर्ड कॉम्बिनेटर " का उपयोग करते हैं। इस इकाई को एक फ़ंक्शन B1 रूप में दर्शाया गया है, जिसका उपयोग इनपुट डेटा के एक सेट पर गणना के दो पास करने के लिए किया जाता है। इसे बेहतर समझने के लिए, इन उदाहरणों पर एक नज़र डालें:

 //   ,  , : const avg1 = B1(div)(sum)(length); const avg2 = arr => div(sum(arr))(length(arr)); const avg3 = arr => ( sum(arr) / length(arr) ); const avg4 = arr => arr.reduce((a, x) => a + x, 0) / arr.length; 

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

5. संचयी औसत मूल्य की गणना के साथ एक पास में समस्या का समाधान

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

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

इस सूत्र का उपयोग करके n संख्याओं का औसत मूल्य पाया जा सकता है:


औसत n + 1 संख्याओं का पता लगाने के लिए, एक ही सूत्र क्या करेगा, लेकिन एक अलग प्रविष्टि में:


यह सूत्र इस प्रकार है:


और यही बात:


यदि आप इसे थोड़ा रूपांतरित करते हैं, तो आपको निम्नलिखित मिलते हैं:


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

 //      // ---------------------------------------------------------------------------- function averageScores({avg, n}, slangTermInfo) {    if (!slangTermInfo.found) {        return {avg, n};       return {        avg: (slangTermInfo.popularity + n * avg) / (n + 1),        n:  n + 1,    }; } //  // ---------------------------------------------------------------------------- //       . const initialVals    = {avg: 0, n: 0}; const averagePopularity = victorianSlang.reduce(averageScores, initialVals).avg; console.log("Average popularity:", averagePopularity); 

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

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

. . , . . , , .

?

? , . , - . , , , . , . , . , , .

, - , . , ? . . — .

:

1. .reduce() .
2. .filter() .map() , — .reduce() .
3. , .
4. .
5. .

, -, ? — . - — , :

1. , . — .
2. , , — .
3. , , — , .

! JavaScript-?