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

Antwoord 2, autoriteit 90%

In Lispzou dit precies de taak zijn voor reduce. Je zou dit soort code zien:

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

Gelukkig hebben we in JavaScript ook reduce! Helaas is +een operator, geen functie. Maar we kunnen het mooi maken! Hier, kijk:

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

Is dat niet mooi? 🙂

Nog beter! Als u ECMAScript 2015 gebruikt (ook bekend als ECMAScript 6), kan dit wees zo mooi:

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

Antwoord 3, autoriteit 21%

Waarom niet verminderen? Het is meestal een beetje contra-intuïtief, maar het is vrij eenvoudig om het te gebruiken om een som te vinden:

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

Antwoord 4, autoriteit 10%

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

Antwoord 5, autoriteit 6%

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

Antwoord 6, autoriteit 4%

Als u Lodash gebruikt, kunt u de functie sumgebruiken

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

Antwoord 7, autoriteit 3%

Dit is mogelijk door alle items te herhalen en ze bij elke iteratie toe te voegen aan een sum-variabele.

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

JavaScript kent geen block scoping, dus sumis toegankelijk:

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

Hetzelfde als hierboven, echter geannoteerd en voorbereid als een eenvoudige functie:

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;
}

Antwoord 8, autoriteit 2%

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

Referentie: Array.prototype .reduce()

Antwoord 9, autoriteit 2%

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

Dit duurt gemiddeld 1,57 ms/run (gemeten over 1000 runs op een array van 100 willekeurige normale getallen), vergeleken met 3,604 ms/run met de methode eval()hierboven en 2.151 ms /run met een standaard for(i,length,++) lus.

Opmerking over de methode: deze test is uitgevoerd op een Google Apps Script-server, dus hun javascript-engines zijn vrijwel hetzelfde als Chrome.

EDIT: --iin plaats van i--bespaart 0,12 ms per run (i– is 1,7)

EDIT: Heilige krachtterm, laat maar deze hele post. Gebruik de methode reduce() die hierboven is genoemd, het is maar 1 ms/run.

10, Autoriteit 2%

Iedereen die op zoek is naar een functionele oneliner zoals ik? Neem dit:

sum = arr.reduce((a, b) => a + b, 0);

(Als u toevallig u wilt ondersteunen, dwz zonder pijlfuncties 🙂

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

11

OK, stel je voor dat je hieronder deze array hebt:

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

Laten we beginnen te kijken vele verschillende manieren om het te doen omdat ik hier geen uitgebreid antwoord kon vinden:

1) met ingebouwde verklein ()

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

2) met behulp van lus

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) met behulp van terwijl Loop

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

4) met behulp van array foreach

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

en noem het zo:

total(arr); //return 10

Het is niet aan te raden om zoiets als dit te Array te maken…

Antwoord 12

Je kunt ook reduceRight gebruiken.

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

wat resulteert in een output als 21.

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

Antwoord 13

Grappige benadering:

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

Antwoord 14

Een standaard JavaScript-oplossing:

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 */

Dit werkt voor mij (het resultaat zou 5 moeten zijn). Ik hoop dat er geen verborgen nadeel is in dit soort oplossingen.

Antwoord 15

Ik ben een beginner met JavaScript en codering in het algemeen, maar ik ontdekte dat een eenvoudige en gemakkelijke manier om de getallen in een array op te tellen als volgt is:

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

Kortom, ik wilde dit bijdragen omdat ik niet veel oplossingen heb gezien die geen ingebouwde functies gebruiken, en deze methode is gemakkelijk te schrijven en te begrijpen.

16

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

Op die manier kun je allerlei exotische dingen in de array plaatsen.

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

Ik ben maar een halve grapje.

17

Gebruik een forlus:

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

of zelfs een forEachlus:

const array = [1, 2, 3, 4];
let result = 0;
array.forEach(number => {
  result += number;
})
console.log(result); // Should give 10

Gebruik voor eenvoud reduce:

const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);
console.log(result); // Should give 100

18

Een kort stuk JavaScript-code zou deze taak doen:

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)

19

Gebruik reduce

let arr = [1, 2, 3, 4];
let sum = arr.reduce((v, i) => (v + i));
console.log(sum);

[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

const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15

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

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

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

alert(
["1", "2", "3", "4"].reduce((a, b) => Number(a) + Number(b), 0)
);

let total = 0;
for (let value of [1, 2, 3, 4]) {
    total += value; 
}

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 ) );

function sumArray(arr) {
    var total = 0;
    arr.forEach(function(element){
        total += element;
    })
    return total;
}
var sum = sumArray([1,2,3,4])
console.log(sum)