So finden Sie die Summe eines Arrays von Zahlen

[1, 2, 3, 4]Wie kann ich bei einem Array die Summe seiner Elemente finden? (In diesem Fall wäre die Summe 10.)

Ich dachte, es $.eachkönnte nützlich sein, bin mir aber nicht sicher, wie ich es implementieren soll.

Empfohlen (mit Standardwert reduzieren)

Array.prototype.reduce kann verwendet werden, um das Array zu durchlaufen und den aktuellen Elementwert zur Summe der vorherigen Elementwerte hinzuzufügen.

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

Ohne Standardwert

Sie erhalten einen TypeError

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

Vor den Pfeilfunktionen von ES6

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

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

Nicht nummerierte Eingänge

Wenn Nicht-Zahlen mögliche Eingaben sind, möchten Sie vielleicht damit umgehen?

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

Nicht empfohlene gefährliche Bewertung

Wir können eval verwenden , um eine Zeichenfolgendarstellung von JavaScript-Code auszuführen. Mit der Funktion Array.prototype.join zum Konvertieren des Arrays in einen String ändern wir [1,2,3] in "1 + 2 + 3", was 6 ergibt.

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('+'))

Das Anzeigen einer Warnung ist natürlich nicht das Schlimmste, was passieren kann. Der einzige Grund, warum ich dies aufgenommen habe, ist die Beantwortung von Ortunds Frage, da ich nicht glaube, dass sie geklärt wurde.

In Lisp wäre dies genau der richtige Job reduce. Sie würden diese Art von Code sehen:

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

Zum Glück haben wir in JavaScript auch reduce! Leider +ist ein Operator keine Funktion. Aber wir können es hübsch machen! Hier, schau:

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

Ist das nicht hübsch? :-)

Noch besser! Wenn Sie ECMAScript 2015 (auch bekannt als ECMAScript 6 ) verwenden, kann dies so hübsch sein:

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

Warum nicht reduzieren? Es ist normalerweise etwas kontraintuitiv, aber es ist ziemlich einfach, es zu verwenden, um eine Summe zu finden:

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

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

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

Wenn Sie zufällig Lodash verwenden, können Sie die Summenfunktion verwenden

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

Dies ist möglich, indem alle Elemente sumdurchlaufen und bei jeder Iteration zu einer Variablen hinzugefügt werden.

var array = [1, 2, 3];

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

JavaScript kennt das Block-Scoping nicht und ist daher sumzugänglich:

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

Das gleiche wie oben, jedoch als einfache Funktion kommentiert und vorbereitet:

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

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

Referenz: Array.prototype.reduce ()

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

Dies dauert durchschnittlich 1,57 ms / Lauf (gemessen über 1000 Läufe auf einem Array von 100 zufälligen Normalzahlen), verglichen mit 3,604 ms / Lauf mit der eval()obigen Methode und 2,151 ms / Lauf mit einem Standard für (i, Länge, ++) ) Schleife.

Hinweis zur Methodik: Dieser Test wurde auf einem Google Apps Script-Server ausgeführt, sodass die Javascript-Engines weitgehend mit denen von Chrome identisch sind.

BEARBEITEN: --ianstatt i--0,12 ms pro Lauf zu speichern (i-- ist 1,7)

EDIT: Holy Expletive, egal diesen ganzen Beitrag. Verwenden Sie die oben erwähnte Methode redu (), sie beträgt nur 1 ms / Lauf.

Sie können auch reduRight verwenden.

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

was ergibt Ausgabe als 21.

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

Wer sucht einen funktionierenden Oneliner wie mich? Nimm das:

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

Lustiger Ansatz:

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

OK, stellen Sie sich vor, Sie haben dieses Array unten:

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

Lassen Sie uns viele verschiedene Möglichkeiten untersuchen , da ich hier keine umfassende Antwort finden konnte:

1) Verwenden der integrierten Reduktion ()

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

2) Verwenden der for-Schleife

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) Verwenden der while-Schleife

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

4) Verwenden des Arrays forEach

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

und nenne es so:

total(arr); //return 10

Es wird nicht empfohlen, einen solchen Prototyp für Array zu erstellen ...

Eine Standard-JavaScript-Lösung:

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

Das funktioniert bei mir (das Ergebnis sollte 5 sein). Ich hoffe, dass diese Art von Lösung keinen versteckten Nachteil hat.

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

Auf diese Weise können Sie alle Arten von exotischen Dingen in das Array aufnehmen.

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

Ich scherze nur halb.

Ich bin ein Anfänger mit JavaScript und Codierung im Allgemeinen, aber ich fand, dass eine einfache und einfache Möglichkeit, die Zahlen in einem Array zu summieren, folgendermaßen ist:

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

Grundsätzlich wollte ich dazu beitragen, weil ich nicht viele Lösungen gesehen habe, die keine integrierten Funktionen verwenden, und diese Methode ist einfach zu schreiben und zu verstehen.

Ein kurzes Stück JavaScript-Code würde diesen Job erledigen:

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)

Einige Leute haben vorgeschlagen, eine .sum()Methode zum hinzuzufügen Array.prototype. Dies wird im Allgemeinen als schlechte Praxis angesehen, daher schlage ich nicht vor, dass Sie es tun.

Wenn Sie immer noch darauf bestehen, ist dies eine prägnante Schreibweise:

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

dann: [1,2].sum(); // 3

Beachten Sie, dass die dem Prototyp hinzugefügte Funktion eine Mischung aus ES5- und ES6-Funktion und Pfeilsyntax verwendet. Das functionwird deklariert, damit die Methode den thisKontext von dem Arrayabrufen kann, mit dem Sie arbeiten. Ich habe das der =>Kürze halber innerhalb des reduceAnrufs verwendet.

Verwenden Sie eine forSchleife:

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

Oder sogar eine forEachSchleife:

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

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

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

Verwenden Sie zur Vereinfachung reduce:

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

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

Keine Notwendigkeit initial value! Denn wenn no übergeben initial valuewird, wird das callback functionnicht für das erste Element der Liste aufgerufen, und das erste Element wird stattdessen als übergeben initial value. Sehr gute Funktion :)

[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

Hier ist eine elegante Einzeilerlösung, die einen Stapelalgorithmus verwendet . Es kann jedoch einige Zeit dauern, bis Sie die Schönheit dieser Implementierung verstanden haben.

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

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

Grundsätzlich akzeptiert die Funktion ein Array und prüft, ob das Array genau ein Element enthält. Wenn false, wird das letzte Element aus dem Stapel entfernt und das aktualisierte Array zurückgegeben.

Das Schöne an diesem Snippet ist, dass die Funktion die arr[0]Überprüfung umfasst , um Endlosschleifen zu verhindern. Sobald das letzte Element erreicht ist, wird die gesamte Summe zurückgegeben.

Sie können die Methode redu () mit dem Lambda-Ausdruck kombinieren:

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

Verwenden reduce

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

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

console.log(sum);

Ich sah alle Antworten für "reduzieren" Lösung gehen

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

Richtigkeit

Sortieren Sie das Array und die Startsumme aus den kleinsten Zahlen (Snippet zeigt Unterschied zu Nicht-Sortierung)

[...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]

Für mehrdimensionale Zahlenreihen verwenden 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

Coole Tricks hier, ich habe eine gute Wahl mit vielen der sicheren traditionellen Antworten, die nicht die Länge des Arrays zwischenspeichern.

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

Ohne die Länge des Arrays zwischenzuspeichern, muss der JS-Compiler das Array bei jeder Iteration der Schleife durchlaufen, um die Länge zu berechnen. In den meisten Fällen ist dies kein unnötiger Overhead. V8 und viele moderne Browser optimieren dies für uns, daher ist dies weniger ein Problem als früher, aber es gibt ältere Geräte, die von diesem einfachen Caching profitieren.

Wenn sich die Länge ändern kann, kann das Zwischenspeichern zu unerwarteten Nebenwirkungen führen, wenn Sie nicht wissen, warum Sie die Länge zwischenspeichern. Bei einer wiederverwendbaren Funktion besteht der einzige Zweck darin, ein Array zu verwenden und die Werte zu addieren tolle Passform.

Hier ist ein CodePen-Link für diese arraySum-Funktion. http://codepen.io/brandonbrule/pen/ZGEJyV

Es ist möglich, dass dies eine veraltete Denkweise ist, die mir am Herzen liegt, aber ich sehe keinen Nachteil darin, sie in diesem Zusammenhang zu verwenden.

Das sind wirklich gute Antworten, aber nur für den Fall, dass die Zahlen wie in der Frage (1,2,3,4) aufeinander folgen, können Sie dies leicht tun, indem Sie die Formel (n * (n + 1)) / 2 anwenden, wobei n ist die letzte Zahl

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

Das ist viel einfacher

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

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

console.log(sum)

Ein einfaches Methodenbeispiel:

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