जावास्क्रिप्ट वस्तुओं की सरणी पर कम करते हैं

Question

कहें कि मैं a.xप्रत्येक तत्व के लिए योग करना चाहता हूं arr।

arr = [{x:1},{x:2},{x:4}]
arr.reduce(function(a,b){return a.x + b.x})
>> NaN

मेरा मानना ​​है कि कुल्हाड़ी किसी समय अपरिभाषित है।

निम्नलिखित ठीक काम करता है

arr = [1,2,4]
arr.reduce(function(a,b){return a + b})
>> 7

मैं पहले उदाहरण में क्या गलत कर रहा हूँ?

Comments

इसके अलावा, मुझे लगता है कि आप arr.reduce(function(a,b){return a + b})दूसरे उदाहरण में मतलब है।

— जेमी वोंग

सुधारों के लिए धन्यवाद। मैं यहाँ कम आया: developer.mozilla.org/en/JavaScript/Reference/Global_Objects/…

— YXD

@ जैमी वोंग यह वास्तव

— JaredMcAteer

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

— जेमी वोंग

जावास्क्रिप्ट संस्करण फ़ायरफ़ॉक्स दुभाषिया के सिर्फ संस्करण हैं, यह उन्हें संदर्भित करने के लिए भ्रमित कर रहा है। केवल ES3 और ES5 है।

— Raynos

Answer 1

पहली पुनरावृत्ति के बाद आपका नंबर वापस आ रहा है और फिर xअगली संपत्ति जो undefinedऔर गणित में undefinedपरिणाम शामिल है, को जोड़ने के लिए इसकी संपत्ति प्राप्त करने की कोशिश कर रहा है NaN।

ऑब्जेक्ट को वापस करने की कोशिश करें जिसमें xपैरामीटर के x गुणों के योग के साथ एक संपत्ति है:

var arr = [{x:1},{x:2},{x:4}];

arr.reduce(function (a, b) {
  return {x: a.x + b.x}; // returns object with property x
})

// ES6
arr.reduce((a, b) => ({x: a.x + b.x}));

// -> {x: 7}

टिप्पणियों से स्पष्टीकरण जोड़ा गया:

अगले पुनरावृत्ति में चर के [].reduceरूप में उपयोग किए गए प्रत्येक पुनरावृत्ति का वापसी मूल्य a।

पुनरावृत्ति 1: a = {x:1}, b = {x:2}, {x: 3}करने के लिए सौंपा aपुनरावृत्ति 2 में

Iteration 2: a = {x:3}, b = {x:4}।

आपके उदाहरण के साथ समस्या यह है कि आप एक नंबर शाब्दिक वापस कर रहे हैं।

function (a, b) {
  return a.x + b.x; // returns number literal
}

पुनरावृत्ति 1: a = {x:1}, b = {x:2}, // returns 3के रूप में aअगले चरण में

पुनरावृत्ति 2: a = 3, b = {x:2}रिटर्नNaN

अनेक शाब्दिक 3नहीं करता है (आम तौर पर) एक संपत्ति कहा जाता है xतो यह है undefinedऔर undefined + b.xरिटर्न NaNऔर NaN + <anything>हमेशा होता हैNaN

स्पष्टता : मैं इस सूत्र में अन्य शीर्ष उत्तर पर अपनी पद्धति को प्राथमिकता देता हूं क्योंकि मैं इस विचार से असहमत हूं कि एक नंबर को लागू करने के लिए एक जादुई संख्या के साथ कम करने के लिए एक वैकल्पिक पैरामीटर पारित करना एक क्लीनर है। इसके परिणामस्वरूप कम पंक्तियाँ लिखी जा सकती हैं लेकिन imo यह कम पठनीय है।

Comments

किसी एरे में तत्वों के प्रत्येक पर संचालन करने के लिए सुनिश्चित करें कि फंक्शन कम हो जाता है। हर बार यह एक मान लौटाता है जिसे ऑपरेशन में अगले 'a' वेरिएबल के रूप में उपयोग किया जाता है। तो पहला पुनरावृति a = {x: 1}, b = {x: 2} फिर दूसरा पुनरावृति a = {x: 3} (प्रथम पुनरावृत्ति का संयुक्त मूल्य), b = {x: 4}। आपके उदाहरण के साथ समस्या जो दूसरी पुनरावृत्ति में थी, जो 3.x + bx जोड़ने की कोशिश कर रहा था, 3 में x नाम की कोई संपत्ति नहीं है, इसलिए यह अपरिभाषित लौट आया और bx में जोड़ते हुए (4) वापस आ गया नंबर नहीं

— JaredMcAtein

मैं स्पष्टीकरण को समझता हूं, लेकिन मैं अभी भी नहीं देखता कि कैसे {x: ...} पुनरावृत्ति 2 को कुल्हाड़ी से रोकता है? वह x क्या दर्शाता है? मैं एक विधि के साथ इस दृष्टिकोण का उपयोग करने की कोशिश की है, और करने के लिए काम नहीं लगता है

— mck

वास्तव में, बस stackoverflow.com/questions/2118123/… को पढ़ें और समझें कि यह कैसे काम करता है .. लेकिन जब आपके पास एक विधि होगी, तो आप इसे कैसे करेंगे, बजाय सीधे विशेषताओं के?

— mck

Answer 2

इसे पूरा करने के लिए एक क्लीनर तरीका एक प्रारंभिक मूल्य प्रदान करता है:

var arr = [{x:1}, {x:2}, {x:4}];
arr.reduce(function (acc, obj) { return acc + obj.x; }, 0); // 7
console.log(arr);

पहली बार अनाम फ़ंक्शन को कॉल किया जाता है, इसे कॉल किया जाता है (0, {x: 1})और रिटर्न मिलता है 0 + 1 = 1। अगली बार, यह कहा जाता है (1, {x: 2})और रिटर्न के साथ 1 + 2 = 3। इसके बाद उसे (3, {x: 4})वापस बुलाया जाता है 7।

Comments

यह समाधान है यदि आपके पास प्रारंभिक मूल्य (कम करने का दूसरा पैरामीटर) है

— टीजे।

थैंक्स, मैं संकेत के लिए दूसरे तर्क के साथ देख रहा था reduce।

— निलासोल

यह स्वीकृत उत्तर की तुलना में कम कोड और अधिक प्रत्यक्ष है - क्या कोई तरीका है जिसमें स्वीकृत उत्तर इससे बेहतर है?

— jbyrd 16

इससे मुझे उस मामले को लेने में मदद मिली जब सरणी लंबाई केवल 1 कभी-कभी होती है।

— हसिएनके

es6 way var arrest = [{x: 1}, {x: 2}, {x: 4}]; let a = arr.reduce ((acc, obj) => acc + obj.x, 0); console.log (क);

— अमर घोडके

Answer 3

टीएल; डीआर, प्रारंभिक मूल्य निर्धारित करें

विनाशकारी का उपयोग करना

arr.reduce( ( sum, { x } ) => sum + x , 0)

बिना विनाश के

arr.reduce( ( sum , cur ) => sum + cur.x , 0)

टाइपस्क्रिप्ट के साथ

arr.reduce( ( sum, { x } : { x: number } ) => sum + x , 0)

चलो विनाशकारी विधि का प्रयास करें:

const arr = [ { x: 1 }, { x: 2 }, { x: 4 } ]
const result = arr.reduce( ( sum, { x } ) => sum + x , 0)
console.log( result ) // 7

इसकी कुंजी प्रारंभिक मूल्य निर्धारित कर रही है। वापसी मूल्य अगले पुनरावृत्ति का पहला पैरामीटर बन जाता है।

शीर्ष उत्तर में प्रयुक्त तकनीक मुहावरेदार नहीं है

स्वीकृत उत्तर "वैकल्पिक" मान को पारित नहीं करने का प्रस्ताव करता है। यह गलत है, क्योंकि मुहावरेदार तरीका यह है कि दूसरे पैरामीटर को हमेशा शामिल किया जाए। क्यों? तीन कारण:

1. खतरनाक - प्रारंभिक मूल्य में नहीं गुजरना खतरनाक है और कॉलबैक फ़ंक्शन लापरवाह होने पर दुष्प्रभाव और उत्परिवर्तन पैदा कर सकते हैं।

देखो

const badCallback = (a,i) => Object.assign(a,i) 

const foo = [ { a: 1 }, { b: 2 }, { c: 3 } ]
const bar = foo.reduce( badCallback )  // bad use of Object.assign
// Look, we've tampered with the original array
foo //  [ { a: 1, b: 2, c: 3 }, { b: 2 }, { c: 3 } ]

हालांकि अगर हमने प्रारंभिक मूल्य के साथ इसे इस तरह से किया है:

const bar = foo.reduce( badCallback, {})
// foo is still OK
foo // { a: 1, b: 2, c: 3 }

रिकॉर्ड के लिए, जब तक आप मूल ऑब्जेक्ट को म्यूट करने का इरादा न करें, Object.assignकिसी खाली ऑब्जेक्ट के पहले पैरामीटर को सेट करें । इस तरह Object.assign({}, a, b, c):।

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

3 - फनर्स का सम्मान करें - जब उसके अंदर का कार्यात्मक बच्चा सामने आता है तो जावास्क्रिप्ट सबसे अच्छा चमकता है। कार्यात्मक दुनिया में, एक मानक है कि आप "तह" या reduceएक सरणी कैसे बनाते हैं । जब आप ऐरे में कैटमोफिज्म को मोड़ते या लगाते हैं , तो आप एक नए प्रकार का निर्माण करने के लिए उस एरे के मूल्यों को लेते हैं। आपको परिणामी प्रकार को संवाद करने की आवश्यकता है - आपको यह करना चाहिए भले ही अंतिम प्रकार सरणी में मानों का हो, किसी अन्य सरणी, या किसी अन्य प्रकार का।

आइए इसके बारे में दूसरे तरीके से सोचते हैं। जावास्क्रिप्ट में, फ़ंक्शन को डेटा की तरह पास किया जा सकता है, यह है कि कॉलबैक कैसे काम करता है, निम्नलिखित कोड का परिणाम क्या है?

[1,2,3].reduce(callback)

क्या यह एक नंबर लौटाएगा? एक वस्तु? इससे यह साफ हो जाता है

[1,2,3].reduce(callback,0)

कार्यात्मक प्रोग्रामिंग कल्पना पर और अधिक पढ़ें: https://github.com/fantasyland/fantasy-land#foldable

कुछ और पृष्ठभूमि

reduceविधि दो पैरामीटर लेता है,

Array.prototype.reduce( callback, initialItem )

callbackसमारोह निम्नलिखित मानकों लेता है

(accumulator, itemInArray, indexInArray, entireArray) => { /* do stuff */ }

पहली पुनरावृत्ति के लिए,

• यदि initialItemप्रदान किया जाता है, तो reduceफ़ंक्शन सरणी के पहले और आइटम के initialItemरूप में गुजरता accumulatorहै itemInArray।

• तो initialItemहै नहीं प्रदान की, reduceसमारोह के रूप में सरणी में पहला आइटम गुजरता है initialItemऔर सरणी के रूप में में दूसरे मद itemInArrayजो व्यवहार भ्रमित किया जा सकता है।

मैं सिखाता हूं और हमेशा कम करने के प्रारंभिक मूल्य को निर्धारित करने की सलाह देता हूं।

आप यहाँ पर दस्तावेज़ देख सकते हैं:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

उम्मीद है की यह मदद करेगा!

Comments

विनाशकारी वही है जो मैं चाहता था। एक जादू की तरह काम करता है। धन्यवाद!

— AleksandrH

Answer 4

दूसरों ने इस सवाल का जवाब दिया है, लेकिन मुझे लगा कि मैं दूसरे दृष्टिकोण में टॉस करूंगा। कुल्हाड़ी को समेटने के लिए सीधे जाने के बजाय, आप एक मानचित्र (कुल्हाड़ी से x) को जोड़ सकते हैं और घटा सकते हैं (x को जोड़ने के लिए):

arr = [{x:1},{x:2},{x:4}]
arr.map(function(a) {return a.x;})
   .reduce(function(a,b) {return a + b;});

बेशक, यह शायद थोड़ा धीमा होने वाला है, लेकिन मैंने इसे एक विकल्प के रूप में उल्लेख करने के लायक समझा।

Answer 5

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

function reducer (accumulator: X, currentValue: Y): X { }

इसका मतलब है कि रेड्यूसर के शरीर को परिवर्तित करने currentValueऔर accumulatorनए के मूल्य के वर्तमान मूल्य के बारे में होना चाहिए accumulator।

यह जोड़ते समय, एक सीधे तरीके से काम करता है, क्योंकि संचायक और तत्व मान दोनों एक ही प्रकार के होते हैं (लेकिन अन्य उद्देश्यों की सेवा करते हैं)।

[1, 2, 3].reduce((x, y) => x + y);

यह सिर्फ इसलिए काम करता है क्योंकि वे सभी नंबर हैं।

[{ age: 5 }, { age: 2 }, { age: 8 }]
  .reduce((total, thing) => total + thing.age, 0);

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

एक बार जब आप जानते हैं कि, आप अन्य n: 1 संबंध समस्याओं के लिए सार्थक कटौती लिख सकते हैं।

दोहराए गए शब्दों को हटाना:

const skipIfAlreadyFound = (words, word) => words.includes(word)
    ? words
    : words.concat(word);

const deduplicatedWords = aBunchOfWords.reduce(skipIfAlreadyFound, []);

पाए गए सभी शब्दों की गिनती प्रदान करना:

const incrementWordCount = (counts, word) => {
  counts[word] = (counts[word] || 0) + 1;
  return counts;
};
const wordCounts = words.reduce(incrementWordCount, { });

एकल फ्लैट सरणी के लिए सरणियों की एक सरणी को कम करना:

const concat = (a, b) => a.concat(b);

const numbers = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
].reduce(concat, []);

किसी भी समय आप चीजों की एक सरणी से जाने के लिए देख रहे हैं, एक भी मूल्य जो 1: 1 से मेल नहीं खाता है, कम कुछ ऐसा है जिसे आप विचार कर सकते हैं।

वास्तव में, मानचित्र और फ़िल्टर दोनों को कटौती के रूप में लागू किया जा सकता है:

const map = (transform, array) =>
  array.reduce((list, el) => list.concat(transform(el)), []);

const filter = (predicate, array) => array.reduce(
  (list, el) => predicate(el) ? list.concat(el) : list,
  []
);

मुझे उम्मीद है कि यह कैसे उपयोग करने के लिए कुछ और संदर्भ प्रदान करता है reduce।

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

const compose = (...fns) => x =>
  fns.reduceRight((x, f) => f(x), x);

const hgfx = h(g(f(x)));
const hgf = compose(h, g, f);
const hgfy = hgf(y);
const hgfz = hgf(z);

Comments

टाइप सिस्टम के संदर्भ में इसे स्पष्ट रूप से समझाने के लिए +1। OTOH, मुझे लगता है कि इस विचार के साथ खुलने से कि यह कई लोगों के लिए अप्रिय हो सकता है ...

— Periata Breatta

Answer 6

पहली पुनरावृत्ति के लिए 'a' सरणी में पहली वस्तु होगी, इसलिए ax + bx 1 + 2 या 3 लौटाएगा। 3. अब अगले पुनरावृत्ति में 3 को a में असाइन किया गया है, इसलिए एक संख्या है अब n कॉलिंग कुल्हाड़ी NaN देगा।

सरल समाधान पहले सरणी में संख्याओं की मैपिंग कर रहा है और फिर नीचे के रूप में उन्हें कम कर रहा है:

arr.map(a=>a.x).reduce(function(a,b){return a+b})

यहां arr.map(a=>a.x)संख्याओं की एक सरणी प्रदान की जाएगी [1,2,4] अब .reduce(function(a,b){return a+b})बिना किसी हैसेल के इन नंबरों को जोड़ने का उपयोग करना आसान होगा

एक अन्य सरल उपाय यह है कि नीचे दिए गए के रूप में 0 से 'ए' असाइन करके एक प्रारंभिक राशि प्रदान की जाए:

arr.reduce(function(a,b){return a + b.x},0)

Answer 7

अपने कम करने के प्रत्येक चरण पर, आप एक नई {x:???}वस्तु नहीं लौटा रहे हैं । इसलिए आपको या तो करने की आवश्यकता है:

arr = [{x:1},{x:2},{x:4}]
arr.reduce(function(a,b){return a + b.x})

या आपको करने की आवश्यकता है

arr = [{x:1},{x:2},{x:4}]
arr.reduce(function(a,b){return {x: a.x + b.x}; }) 

Comments

पहले उदाहरण के लिए डिफ़ॉल्ट मान की आवश्यकता होती है (जैसे 0) अन्यथा "a" पहले पुनरावृत्ति में अपरिभाषित है।

— ग्रिफिन

Answer 8

पहले चरण में, यह a1 के मान के रूप में ठीक काम करेगा और यह b2 का होगा, लेकिन जैसा कि 2 + 1 वापस आ जाएगा और अगले चरण bमें वापसी का मूल्य होगा from step 1 i.e 3और इसलिए b.xअपरिभाषित होगा। .और अपरिभाषित + anyNumber NaN होगा और इसीलिए आपको वह परिणाम मिल रहा है।

इसके बजाय आप शून्य यानी प्रारंभिक मूल्य देकर यह कोशिश कर सकते हैं

arr.reduce(function(a,b){return a + b.x},0);

---

Comments

कृपया यह देखने के लिए अपडेट करें कि आपका दृष्टिकोण दूसरों से अलग कैसे है।

— kwelch

Answer 9

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

उदाहरण के लिए:

const myArray = [{ id: 1, value: 10}, { id: 2, value: 20}];

सबसे पहले, आपको अपनी रुचि के नए सरणी में अपने सरणी को मैप करना चाहिए, यह इस उदाहरण में मूल्यों की एक नई सरणी हो सकती है।

const values = myArray.map(obj => obj.value);

यह कॉल बैक फ़ंक्शन मूल सरणी से केवल मान युक्त एक नया सरणी लौटाएगा और इसे मान कॉन्स्ट पर संग्रहीत करेगा। अब आपका मान कॉन्स्टेबल इस तरह से एक सरणी है:

values = [10, 20];

और अब आप अपना कम प्रदर्शन करने के लिए तैयार हैं:

const sum = values.reduce((accumulator, currentValue) => { return accumulator + currentValue; } , 0);

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

अब आपके पास 30 की वैल्यू के साथ आपकी नई कांस्टेबल राशि है।

Answer 10

एक संग्रह पर समारोह iterates कम करें

arr = [{x:1},{x:2},{x:4}] // is a collection

arr.reduce(function(a,b){return a.x + b.x})

अनुवाद करने के लिए:

arr.reduce(
    //for each index in the collection, this callback function is called
  function (
    a, //a = accumulator ,during each callback , value of accumulator is 
         passed inside the variable "a"
    b, //currentValue , for ex currentValue is {x:1} in 1st callback
    currentIndex,
    array
  ) {
    return a.x + b.x; 
  },
  accumulator // this is returned at the end of arr.reduce call 
    //accumulator = returned value i.e return a.x + b.x  in each callback. 
);

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

इसे हल करने के लिए, मूल्य 0 के साथ "संचायक" को इनिशियलाइज़ करें क्योंकि केसी का उत्तर ऊपर दिखाया गया है।

"कम" फ़ंक्शन के इन-आउट को समझने के लिए, मैं आपको इस फ़ंक्शन के स्रोत कोड को देखने का सुझाव दूंगा। लोदाश लाइब्रेरी ने फ़ंक्शन को कम कर दिया है जो ES6 में "कम" फ़ंक्शन के समान कार्य करता है।

यहाँ लिंक है: स्रोत कोड को कम करें

Answer 11

सभी xसहारा की राशि वापस करने के लिए :

arr.reduce(
(a,b) => (a.x || a) + b.x 
)

Comments

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

— एंड्रयू

Answer 12

आप मानचित्र का उपयोग कर सकते हैं और कार्यों को कम कर सकते हैं

const arr = [{x:1},{x:2},{x:4}];
const sum = arr.map(n => n.x).reduce((a, b) => a + b, 0);

Answer 13

ऐरे कम फ़ंक्शन तीन पैरामीटर लेता है जैसे, initialValue (डिफ़ॉल्ट 0 है), संचायक और वर्तमान मान। डिफ़ॉल्ट रूप से आरम्भिक वैल्यू का मान "0" होगा। जो संचायक द्वारा लिया जाता है

इसे कोड में देखते हैं।

var arr =[1,2,4] ;
arr.reduce((acc,currVal) => acc + currVal ) ; 
// (remember Initialvalue is 0 by default )

//first iteration** : 0 +1 => Now accumulator =1;
//second iteration** : 1 +2 => Now accumulator =3;
//third iteration** : 3 + 4 => Now accumulator = 7;
No more array properties now the loop breaks .
// solution = 7

अब प्रारंभिक मूल्य के साथ एक ही उदाहरण:

var initialValue = 10;
var arr =[1,2,4] ;
arr.reduce((acc,currVal) => acc + currVal,initialValue ) ; 
/
// (remember Initialvalue is 0 by default but now it's 10 )

//first iteration** : 10 +1 => Now accumulator =11;
//second iteration** : 11 +2 => Now accumulator =13;
//third iteration** : 13 + 4 => Now accumulator = 17;
No more array properties now the loop breaks .
//solution=17

समान वस्तु सरणियों के लिए भी लागू होता है (वर्तमान स्टैकओवरफ़्लो प्रश्न):

var arr = [{x:1},{x:2},{x:4}]
arr.reduce(function(acc,currVal){return acc + currVal.x}) 
// destructing {x:1} = currVal;
Now currVal is object which have all the object properties .So now 
currVal.x=>1 
//first iteration** : 0 +1 => Now accumulator =1;
//second iteration** : 1 +2 => Now accumulator =3;
//third iteration** : 3 + 4 => Now accumulator = 7;
No more array properties now the loop breaks 
//solution=7

MIND में शुरू करने का एक तरीका डिफ़ॉल्ट रूप से प्रारंभिक है 0 है और मुझे कुछ भी दिया जा सकता है जिसका मेरा मतलब है {}, [] और संख्या

Answer 14

    
  
 //fill creates array with n element
 //reduce requires 2 parameter , 3rd parameter as a length
 var fibonacci = (n) => Array(n).fill().reduce((a, b, c) => {
      return a.concat(c < 2 ? c : a[c - 1] + a[c - 2])
  }, [])
  console.log(fibonacci(8))

Answer 15

आपको संचायक के लिए कुल्हाड़ी का उपयोग नहीं करना चाहिए, इसके बजाय आप इस तरह से कर सकते हैं `गिरफ्तारी = [{x: 1}, {x: 2}, {x: 4}]

arr.reduce (फ़ंक्शन (ए, बी) {ए + बीएक्स}, 0) `