संख्याओं की एक संख्या का योग कैसे ज्ञात करें

Question

एक सरणी को देखते हुए [1, 2, 3, 4], मैं इसके तत्वों का योग कैसे पा सकता हूँ? (इस मामले में, योग होगा10 ।)

मैंने सोचा $.eachकि यह उपयोगी हो सकता है, लेकिन मुझे यकीन नहीं है कि इसे कैसे लागू किया जाए।

Comments

यह प्रश्न मेटा चर्चा के

— मदार का भूत

@ tereško गूगल के प्रति अनिच्छा स्टैकओवरफ़्लो पर एक वैध करीबी कारण नहीं है। कृपया डाउनवोट करें यदि आपको लगता है कि प्रश्न ठीक नहीं है (पुनः) खोजा गया है। (जवाबों को देखते हुए - यह एक अत्यधिक विवादास्पद विषय लगता है, जिसमें कई संभावित समाधान शामिल हैं, जिनमें कुछ अत्यधिक

— उथल

नोट: यहां अधिकांश उत्तर अनिवार्य रूप से गणना करते हैं a[0] + a[1] + ..., जो कि गैर-संख्या तत्वों के होने पर स्ट्रिंग संघनन में बदल सकते हैं। जैसे ['foo', 42].reduce((a,b)=>a+b, 0) === "0foo42"।

— बेनी चेर्नियाव्स्की-पास्किन

Reducer में निर्मित कोई भी Array.reduce को नहीं खिला सकता है? कुछ सोचकर [1,2,3].reduce(Math.sum)।

— फिल

Answer 1

अनुशंसित (डिफ़ॉल्ट मान के साथ कम करें)

Array.prototyp.reduce का उपयोग सरणी के माध्यम से पुनरावृत्त करने के लिए किया जा सकता है, वर्तमान तत्व मान को पिछले तत्व मानों के योग में जोड़ सकता है।

console.log(
  [1, 2, 3, 4].reduce((a, b) => a + b, 0)
)
console.log(
  [].reduce((a, b) => a + b, 0)
)

डिफ़ॉल्ट मान के बिना

आपको एक TypeError मिलता है

console.log(
  [].reduce((a, b) => a + b)
)

ES6 के एरो फ़ंक्शंस से पहले

console.log(
  [1,2,3].reduce(function(acc, val) { return acc + val; }, 0)
)

console.log(
  [].reduce(function(acc, val) { return acc + val; }, 0)
)

गैर-संख्या इनपुट

यदि गैर-संख्या संभव इनपुट हैं, तो आप इसे संभालना चाह सकते हैं?

console.log(
  ["hi", 1, 2, "frog"].reduce((a, b) => a + b)
)

let numOr0 = n => isNaN(n) ? 0 : n

console.log(
  ["hi", 1, 2, "frog"].reduce((a, b) => 
    numOr0(a) + numOr0(b))
)

गैर-अनुशंसित खतरनाक eval उपयोग

हम जावास्क्रिप्ट कोड के एक स्ट्रिंग प्रतिनिधित्व को निष्पादित करने के लिए eval का उपयोग कर सकते हैं । सरणी को स्ट्रिंग में बदलने के लिए Array.prototyp.join फ़ंक्शन का उपयोग करते हुए, हम [1,2,3] को "1 + 2 + 3" में बदलते हैं, जो 6 का मूल्यांकन करता है।

console.log(
  eval([1,2,3].join('+'))
)

//This way is dangerous if the array is built
// from user input as it may be exploited eg: 

eval([1,"2;alert('Malicious code!')"].join('+'))

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

Comments

आप जानते हैं कि लंबे समय के बाद reduce()एक साधारण अनुक्रमित for()लूप की तुलना में यह जादू अभी भी 25-30% धीमा है ? jsperf.com/reduce-vs-loop/4

— तेवमदर

यदि संख्या "0" है, तो यह समस्याओं में चलता है - इसे स्ट्रिंग के रूप में व्याख्या की जा सकती है, जो भी कारण हो। मेरे लिए 1 * a + 1 * b जोड़ना काम किया। गति के रूप में, यह लिखना आसान था और मुझे गति के बारे में परवाह नहीं है

— पीटर काई

Answer 2

में लिस्प , वास्तव में के लिए काम हो this'd reduce। आप इस तरह का कोड देखेंगे:

(reduce #'+ '(1 2 3)) ; 6

सौभाग्य से, जावास्क्रिप्ट में, हमारे पास भी है reduce! दुर्भाग्य से, +एक ऑपरेटर है, एक फ़ंक्शन नहीं है। लेकिन हम इसे सुंदर बना सकते हैं! यहां देखें:

const sum = [1, 2, 3].reduce(add,0); // with initial value to avoid when the array is empty

function add(accumulator, a) {
    return accumulator + a;
}

console.log(sum); // 6

सुंदर है कि नहीं? :-)

और भी बेहतर! यदि आप ECMAScript 2015 (उर्फ ECMAScript 6 ) का उपयोग कर रहे हैं , तो यह बहुत सुंदर हो सकता है:

const sum = [1, 2, 3].reduce((partial_sum, a) => partial_sum + a,0); 
console.log(sum); // 6

Comments

मान लें कि हम सभी ES2015 का उपयोग करते हैं, तो हम इसे कम क्रिया कर सकते हैं:[1, 2, 3].reduce((a,b)=>a+b)

— Denys Séguret

मुझे आश्चर्य है कि अगर एक फ़ंक्शन (ए, बी) के साथ कम करने का निष्पादन समय एक मैनुअल पुनरावृत्ति और योग के बराबर है या यदि कुछ काफी ओवरहेड शामिल हैं?

— त्रिशूल

मुझे विश्वास है कि यह ध्यान देने योग्य है कि उत्तर वास्तव में आपके द्वारा लिंक किए गए पृष्ठ पर पाया जा सकता है: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— एलेक्स कोहेन

मैं एरे में कुछ तरीके Array.prototype.sum = function() { return this.reduce((a,b) => a+b, 0); } Array.prototype.avg = function() { return this.reduce((a,b) => a+b, 0)/this.length; }

— जोड़ूंगा

@ वापस यह एक एकल मूल्य में एक सरणी कम कर देता है।

— फ्लोरियन मार्गाइन

Answer 3

कम क्यों नहीं हुआ? यह आमतौर पर थोड़ा सा सहज है, लेकिन एक राशि खोजने के लिए इसका उपयोग करना बहुत सरल है:

var a = [1,2,3];
var sum = a.reduce(function(a, b) { return a + b; }, 0);

Comments

IE8 इसका समर्थन नहीं करता है, और इसे जोड़ने पर jQuery का इरादा नहीं है। हालाँकि, प्रोटोटाइप में यह है।

— इस्माईल स्मरनॉज़

@ इस्माईल, आप अंडरस्कोरजेएस का उपयोग कर सकते हैं, जो कि उपलब्ध होने पर ब्राउज़र के कार्यान्वयन में वापस आ जाता है, या अन्यथा स्वयं लागू होता है।

— पाब्लो डियाज़

प्रति-सहज क्या है reduce()?

— कैनन

@ s4nji एकल रिटर्न मान के लिए एक सरणी को Array.prototype.reduce() कम करता है।

— कैनन

@ s4nji ... जब तक आप एक सॉस कम नहीं कर रहे हैं - जिस स्थिति में आप इसे अपनी अनिवार्यता के लिए नीचे ला रहे हैं, यानी पानी के बिना सभी स्वादों का योग। :-)

— सीबी डू रिट्ज़

Answer 4

var arr = [1,2,3,4];
var total=0;
for(var i in arr) { total += arr[i]; }

Comments

यह ऊपर jQuery.each () समाधान की तुलना में तेज़ है।

— गुस्सा डैन

@Sprog: हालाँकि, उपयोग (var i=0; i<arr.length; i++)करना और भी तेज़ है। और फिर भी, उपयोग var sum=0; var i=arr.length; while(i--) sum += arr[i]करना अभी भी तेज है।

— रेकिंग

for... inसरणियों पर छोरों का उपयोग इस मामले में काम करता है _ संयोगवश_ और क्योंकि सरणियाँ वस्तुओं का विस्तार करती हैं। रेकिंग का समाधान बेहतर है

— बेंजामिन

@BenjaminGruenbaum ने कहा कि कुछ भी नहीं है गुण को सरणी के प्रोटोटाइप में जोड़ा गया है ...

— कैनन

@ YSC नहीं, यह नहीं है। for...inजावास्क्रिप्ट में एक लूप इंडेक्स लेता है, जो कोडर्स के लिए एक आम ठोकर है जो मूल्यों को प्राप्त करने की उम्मीद करता है। ( for(var i in [1,2,3]) { console.log(i); }एक सांत्वना में प्रयास करें ।)

— एम्बर

Answer 5

var total = 0;
$.each(arr,function() {
    total += this;
});

Comments

कृपया, कृपया, कृपया reduceनीचे दिए गए उत्तर का उपयोग करें; जब आपके पास नहीं है, तो परिवर्तनशील संस्करण घोषित न करें।

— ब्रूनो ग्रिडर

यह जवाब मेटा चर्चा के

— मदार का भूत

कृपया इसका उपयोग न करें, भले ही यह "स्वीकृत उत्तर" हो; नीचे फ्लोरियन द्वारा जवाब बहुत बेहतर है!

— एंडी सिनक्लेयर

@BrunoGrieder "जब आपके पास नहीं है तो उत्परिवर्ती संस्करण घोषित न करें" एक अनिवार्य भाषा के बारे में एक अत्यंत पक्षपाती राय है , यह कल्पना के किसी भी खंड द्वारा शायद ही एक कोड गंध है। टायलर के उत्तर में कुछ भी गलत नहीं है, और टायलर और फ्लोरियन की शैली के बीच एकमात्र अंतर है।

— रोब

ओपी से: मैंने सोचा था कि $ .each उपयोगी हो सकता है, लेकिन मुझे यकीन नहीं है कि इसे कैसे लागू किया जाए। यह शायद सबसे अच्छा नहीं है, लेकिन ओपी के अनुरोध का जवाब दें।

Answer 6

यदि आप लॉडश का उपयोग कर रहे हैं, तो आप राशि फ़ंक्शन का उपयोग कर सकते हैं

array = [1, 2, 3, 4];
sum = _.sum(array); // sum == 10

Answer 7

यह सभी वस्तुओं पर लूपिंग, और एक-करने sumयोग्य के लिए प्रत्येक पुनरावृत्ति पर उन्हें जोड़ना संभव है।

var array = [1, 2, 3];

for (var i = 0, sum = 0; i < array.length; sum += array[i++]);

जावास्क्रिप्ट ब्लॉक ब्लॉकिंग पता नहीं है, तो sumaccesible होगा:

console.log(sum); // => 6

उपरोक्त के समान, लेकिन एनोटेट और एक साधारण फ़ंक्शन के रूप में तैयार किया गया:

function sumArray(array) {
  for (
    var
      index = 0,              // The iterator
      length = array.length,  // Cache the array length
      sum = 0;                // The total amount
      index < length;         // The "for"-loop condition
      sum += array[index++]   // Add number on each iteration
  );
  return sum;
}

Comments

चतुर होते हुए, मैं कोड sumको लूप के बाहर अधिक पठनीय घोषित करूँगा ।

— बेनी चेर्नियाव्स्की-पास्किन

@ BeniCherniavsky-Paskin हाँ, यहाँ भी वही ... न जाने क्यों मैंने उस दिन ऐसा नहीं किया था ... हालाँकि, मैं इसे वैसे ही रहने दूँगा! यह सिर्फ एक उदाहरण है कि हम कैसे कर सकते हैं ... ?)

— यार्न

ES6 के बाद से, जावास्क्रिप्ट को ब्लॉक स्कूपिंग के साथ constऔर पता है let। तो आप लूप के sumबाहर की घोषणा कर सकते हैं । आप लूप से पहले सरणी की लंबाई को कैश भी कर सकते हैंforlet sum = 0;const length = array.length;

— KSK

Answer 8

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

संदर्भ: Array.prototyp.reduce ()

Comments

अगर arrहै तो यह विफल हो जाएगा []।

डिफ़ॉल्ट मान जोड़ें, जैसे:arr.reduce(function (a, b) { return a + b; }, 0);

— Ngz

Answer 9

// Given array 'arr'
var i = arr.length;
var sum = 0;
while (--i) sum += arr[i];

यह औसतन 1.57 एमएस / रन (100 यादृच्छिक सामान्य संख्याओं की एक सरणी पर 1000 से अधिक रन मापा जाता है) की तुलना में 3.604 एमएस / रन होगा। eval() ऊपर विधि के और 2.151 एमएस / रन मानक के लिए (i, लंबाई, ++) ) लूप।

कार्यप्रणाली नोट: यह परीक्षण Google Apps स्क्रिप्ट सर्वर पर चलाया गया था, इसलिए उनके जावास्क्रिप्ट इंजन क्रोम के समान ही हैं।

संपादित करें: प्रत्येक रन 0.12 एमएस --iकी i--बचत के बजाय (i-- 1.7 है)

संपादित करें: पवित्र भावपूर्ण, इस पूरी पोस्ट पर कभी ध्यान न दें। ऊपर बताए गए कम () विधि का उपयोग करें, यह केवल 1 एमएस / रन है।

Comments

मुझे आपके द्वारा उपयोग किए गए समय से प्यार है। आपका जवाब सिर्फ यह नहीं कहता है "मुझे उठाओ, मैं सबसे अच्छा हूँ!" इसके बजाय यह हमें दिखाता है कि क्यों । वैसे भी, while (--i) do_somethingअन्य चीजों के लिए भी काम कर सकते हैं।

— रेडवॉल्फ कार्यक्रम

var sum = arr[0]

— Noobninja

Answer 10

आप भी कम का उपयोग कर सकते हैं।

[1,2,3,4,5,6].reduceRight(function(a,b){return a+b;})

जिसके परिणामस्वरूप आउटपुट 21 है।

संदर्भ: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight

Comments

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

— जैक गिफिन

Answer 11

किसी को भी मेरे जैसे एक कार्यात्मक oneliner की तलाश में? इसे लो:

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

Comments

आप 2 arr.reduce(function(a, b) { return a + b;}, 0);

— पैरा के

धन्यवाद! मैं उसे शामिल करूँगा

— गीक-मर्लिन

Answer 12

मजेदार दृष्टिकोण:

eval([1,2,3].join("+"))

Comments

इस कोड में क्या हो रहा है, यह बताकर कृपया आप इस उत्तर पर विस्तार कर सकते हैं? यह काम क्यों करता है? यह वास्तव में क्या करता है? ये चीजें उत्तर की गुणवत्ता को बेहतर बनाने में मदद करती हैं।

— ओरटंड

@ user40521 ने पहले से ही मेरे सोचने के तरीके का उत्तर दिया है। मैंने इसे नहीं देखा।

— इलेक्ट्रॉन

हालांकि यह छोटा और मीठा है, और निश्चित रूप से दिलचस्प है, यह भी बहुत अक्षम है। उपयोग करना reduceनिश्चित रूप से बहुमत के लिए बेहतर है, यदि सभी मामलों में नहीं।

— निन्जाकन्नन

[1,"2;YourProgram.ripToShreds();3",4]

— एर्म

इसलिए मैं गलत उत्तर देने की NaNकोशिश कर रहा हूं eval(['alert("removing your computer")',2,3].join("+"))0/10

— पाई 6k

Answer 13

ठीक है, कल्पना कीजिए कि आपके पास यह सरणी है:

const arr = [1, 2, 3, 4];

आइए कई अलग-अलग तरीकों से देखना शुरू करें इसे करने के लिए से देखना शुरू कर सकते हैं क्योंकि मुझे यहां कोई व्यापक जवाब नहीं मिला:

1) अंतर्निहित कम () का उपयोग करना

function total(arr) {
  if(!Array.isArray(arr)) return;
  return arr.reduce((a, v)=>a + v);
}

2) लूप के लिए उपयोग करना

function total(arr) {
  if(!Array.isArray(arr)) return;
  let totalNumber = 0;
  for (let i=0,l=arr.length; i<l; i++) {
     totalNumber+=arr[i];
  }
  return totalNumber;
}

3) लूप का उपयोग करते हुए

function total(arr) {
  if(!Array.isArray(arr)) return;
  let totalNumber = 0, i=-1;
  while (++i < arr.length) {
     totalNumber+=arr[i];
  }
  return totalNumber;
}

4) सरणी forEach का उपयोग करना

function total(arr) {
  if(!Array.isArray(arr)) return;
  let sum=0;
  arr.forEach(each => {
    sum+=each;
  });
  return sum;
};

और इसे इस तरह से कॉल करें:

total(arr); //return 10

यह कुछ इस तरह का ऐरे के लिए प्रोटोटाइप की सिफारिश नहीं है ...

Answer 14

एक मानक जावास्क्रिप्ट समाधान:

var addition = [];
addition.push(2);
addition.push(3);

var total = 0;
for (var i = 0; i < addition.length; i++)
{
    total += addition[i];
}
alert(total);          // Just to output an example
/* console.log(total); // Just to output an example with Firebug */

यह मेरे लिए काम करता है (परिणाम 5 होना चाहिए)। मुझे उम्मीद है कि इस तरह के समाधान में कोई छिपा हुआ नुकसान नहीं है।

Comments

साथ ही, कोई भी C या Java प्रोग्रामर इसे समझने में सक्षम होगा।

— ऑड्रियस मेस्कॉस्कस

सभी मूल्यों को संक्षेप में प्रस्तुत करने के सरल उद्देश्य के लिए लूप के लिए सरल सादे पुराने निष्पादन समय के संदर्भ में कोई प्रतिद्वंद्वी नहीं है

— फेडगेह

केवल समस्या यह है, यह थोड़ा कष्टप्रद है जब आपके पास 20 छोरों के लिए एक दूसरे में

— निहित हैं

Answer 15

var totally = eval(arr.join('+'))

इस तरह आप सभी प्रकार की विदेशी चीजों को सरणी में रख सकते हैं।

var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]

मैं केवल आधा मजाक कर रहा हूं।

Comments

मैं आधा

— हँसा

eval(['alert("removing your computer")',2,3].join("+"))

— पीआईकेके

Answer 16

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

    var myNumbers = [1,2,3,4,5]
    var total = 0;
    for(var i = 0; i < myNumbers.length; i++){
        total += myNumbers[i];
    }

असल में, मैं इसमें योगदान करना चाहता था क्योंकि मैंने कई समाधान नहीं देखे हैं जो अंतर्निहित कार्यों का उपयोग नहीं करते हैं, और यह विधि लिखना और समझना आसान है।

Comments

यह 2012 के उत्तर या इस 2014 के उत्तर से कैसे भिन्न है ? आपके द्वारा देखे गए दो समाधान नहीं हैं।

— डैन डेस्केल्सकू

Answer 17

जावास्क्रिप्ट कोड का एक छोटा टुकड़ा यह काम करेगा:

var numbers = [1,2,3,4];
var totalAmount = 0;

for (var x = 0; x < numbers.length; x++) {

    totalAmount += numbers[x];
}

console.log(totalAmount); //10 (1+2+3+4)

Answer 18

कुछ लोगों ने एक .sum()विधि जोड़ने का सुझाव दिया है Array.prototype। यह आमतौर पर बुरा अभ्यास माना जाता है इसलिए मैं यह सुझाव नहीं दे रहा हूं कि आप इसे करते हैं।

यदि आप अभी भी इसे करने पर जोर देते हैं तो यह इसे लिखने का एक संक्षिप्त तरीका है:

Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}

फिर: [1,2].sum(); // 3

ध्यान दें कि प्रोटोटाइप में जोड़ा गया फ़ंक्शन ES5 और ES6 फ़ंक्शन और एरो सिंटैक्स के मिश्रण का उपयोग कर रहा है। functionविधि प्राप्त करने के लिए अनुमति देने के लिए घोषित किया जाता है thisसे संदर्भ Arrayहै कि आप पर काम कर रहे हैं। मैंने कॉल के =>अंदर संक्षिप्तता के लिए उपयोग किया है reduce।

Answer 19

एक forलूप का उपयोग करें :

const array = [1, 2, 3, 4];
let result = 0;

for (let i = 0; i < array.length - 1; i++) {
  result += array[i];
}

console.log(result); // Should give 10

या एक forEachलूप भी :

const array = [1, 2, 3, 4];
let result = 0;

array.forEach(number => {
  result += number;
})

console.log(result); // Should give 10

सादगी के लिए, उपयोग करें reduce:

const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);

console.log(result); // Should give 100

Answer 20

कोई जरूरत नहीं है initial value! क्योंकि यदि कोई initial valueपारित नहीं होता है, तो callback functionसूची के पहले तत्व पर लागू नहीं किया जाता है, और पहले तत्व को इसके बजाय पास किया जाता है initial value। बहुत ही ऊ ऊ सुविधा :)

[1, 2, 3, 4].reduce((a, x) => a + x) // 10
[1, 2, 3, 4].reduce((a, x) => a * x) // 24
[1, 2, 3, 4].reduce((a, x) => Math.max(a, x)) // 4
[1, 2, 3, 4].reduce((a, x) => Math.min(a, x)) // 1

Answer 21

यहां एक सुंदर एक-लाइनर समाधान है जो स्टैक एल्गोरिथ्म का उपयोग करता है , हालांकि इस कार्यान्वयन की सुंदरता को समझने में कुछ समय लग सकता है।

const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);

getSum([1, 2, 3, 4, 5]) //15

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

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

Answer 22

आप मेमने की अभिव्यक्ति के साथ कम () विधि को जोड़ सकते हैं:

[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);

Answer 23

उपयोग reduce

let arr = [1, 2, 3, 4];

let sum = arr.reduce((v, i) => (v + i));

console.log(sum);

Answer 24

मैंने सभी उत्तर 'कम' समाधान के लिए देखे

var array = [1,2,3,4]
var total = 0
for (var i = 0; i < array.length; i++) {
    total += array[i]
}
console.log(total)

Answer 25

शुद्धता

क्रमबद्ध सरणी और प्रारंभ योग छोटी संख्याएँ (स्निपेट निरर्थक के साथ अंतर दिखाता है)

[...arr].sort((a,b)=>a-b).reduce((a,c)=>a+c,0)

arr=[.6,9,.1,.1,.1,.1]

sum     =                       arr.reduce((a,c)=>a+c,0)
sortSum = [...arr].sort((a,b)=>a-b).reduce((a,c)=>a+c,0)

console.log('sum:     ',sum);
console.log('sortSum:',sortSum);
console.log('sum==sortSum :', sum==sortSum);

// we use .sort((a,b)=>a-b) instead .sort() because
// that second one treat elements like strings (so in wrong way)
// e.g [1,10,9,20,93].sort() -->  [1, 10, 20, 9, 93]

संख्याओं के बहुआयामी उपयोग के लिए arr.flat(Infinity)

arr= [ [ [1,2,3,4],[1,2,3,4],[1,2,3,4] ],
       [ [1,2,3,4],[1,2,3,4],[1,2,3,4] ] ];
      
sum = arr.flat(Infinity).reduce((a,c)=> a+c,0);

console.log(sum);  // 60

Answer 26

यहाँ कूल ट्रिक्स, मुझे बहुत सारे सुरक्षित पारंपरिक उत्तरों के साथ एक नाइट पिक मिली है, जो सरणी की लंबाई को कैशिंग नहीं करती है।

function arraySum(array){
  var total = 0,
      len = array.length;

  for (var i = 0; i < len; i++){
    total += array[i];
  }

  return total;
};

var my_array = [1,2,3,4];

// Returns 10
console.log( arraySum( my_array ) );

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

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

इस arraySum फ़ंक्शन के लिए एक CodePen लिंक यहां दिया गया है। http://codepen.io/brandonbrule/pen/ZGEJyV

यह संभव है कि यह एक पुरानी मानसिकता है जो मेरे साथ फंस गई है, लेकिन मुझे इस संदर्भ में इसका उपयोग करने का कोई नुकसान नहीं दिखता है।

Comments

लंबाई को कैशिंग करने का मुद्दा एक लाल हेरिंग है। JS इंजन बिना पलक झपकाए आपके लिए इसे ऑप्टिमाइज़ करेंगे।

Answer 27

वे वास्तव में महान जवाब हैं, लेकिन सिर्फ अगर मामले में संख्या क्रम में हैं (1,2,3,4) तो आप आसानी से कर सकते हैं कि फॉर्मूला लागू करके (n * (n + 1)) / 2 कहाँ n अंतिम संख्या है

Answer 28

Object.defineProperty(Object.prototype, 'sum', {
    enumerable:false,
    value:function() {
        var t=0;for(var i in this)
            if (!isNaN(this[i]))
                t+=this[i];
        return t;
    }
});

[20,25,27.1].sum()                 // 72.1
[10,"forty-two",23].sum()          // 33
[Math.PI,0,-1,1].sum()             // 3.141592653589793
[Math.PI,Math.E,-1000000000].sum() // -999999994.1401255

o = {a:1,b:31,c:"roffelz",someOtherProperty:21.52}
console.log(o.sum());              // 53.519999999999996

Comments

क्या यह कोड आपके ऑपरेटिंग सिस्टम को हटा देता है? या यह आपकी व्यक्तिगत जानकारी मुझे भेजता है?

Answer 29

यह बहुत आसान है

function sumArray(arr) {
    var total = 0;
    arr.forEach(function(element){
        total += element;
    })
    return total;
}

var sum = sumArray([1,2,3,4])

console.log(sum)

Answer 30

एक सरल विधि उदाहरण:

function add(array){
    var arraylength = array.length;
    var sum = 0;
    for(var timesToMultiply = 0; timesToMultiply<arraylength; timesToMultiply++){
        sum += array[timesToMultiply];
    }

    return sum;
}

console.log(add([1, 2, 3, 4]));