Collectives™ on Stack Overflow
Find centralized, trusted content and collaborate around the technologies you use most.
Learn more about Collectives
Teams
Q&A for work
Connect and share knowledge within a single location that is structured and easy to search.
Learn more about Teams
Given an array
[1, 2, 3, 4]
, how can I find the sum of its elements? (In this case, the sum would be
10
.)
I thought
$.each
might be useful, but I'm not sure how to implement it.
–
–
–
This'd be exactly the job for
reduce
.
If you're using ECMAScript 2015 (aka
ECMAScript 6
):
const sum = [1, 2, 3].reduce((partialSum, a) => partialSum + a, 0);
console.log(sum); // 6
For older JS:
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
Isn't that pretty? :-)
–
–
//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('+'))
–
–
–
Why not reduce? It's usually a bit counter intuitive, but using it to find a sum is pretty straightforward:
var a = [1,2,3];
var sum = a.reduce(function(a, b) { return a + b; }, 0);
–
–
–
–
–
–
–
–
–
–
–
sum = arr.reduce((a, b) => a + b, 0);
(If you happen to have to support ye olde IE without arrow functions:)
sum = arr.reduce(function (a, b) {return a + b;}, 0);
Note that 0 is the initial value here, so you can use that as offset if needed. Also note that this initial value is needed, otherwise calling the function with an empty array will error.
–
–
This is possible by looping over all items, and adding them on each iteration to a sum-variable.
var array = [1, 2, 3];
for (var i = 0, sum = 0; i < array.length; sum += array[i++]);
JavaScript doesn't know block scoping, so sum will be accesible:
console.log(sum); // => 6
The same as above, however annotated and prepared as a simple function:
function sumArray(array) {
for (
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;
–
–
Let's start looking into many different ways to do it as I couldn't find any comprehensive answer here:
1) Using built-in reduce()
function total(arr) {
if(!Array.isArray(arr)) return;
return arr.reduce((a, v)=>a + v);
2) Using for loop
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) Using while loop
function total(arr) {
if(!Array.isArray(arr)) return;
let totalNumber = 0, i=-1;
while (++i < arr.length) {
totalNumber+=arr[i];
return totalNumber;
4) Using array forEach
function total(arr) {
if(!Array.isArray(arr)) return;
let sum=0;
arr.forEach(each => {
sum+=each;
return sum;
and call it like this:
total(arr); //return 10
It's not recommended to prototype something like this to Array...
–
alert(total); // Just to output an example
/* console.log(total); // Just to output an example with Firebug */
This works for me (the result should be 5). I hope there is no hidden disadvantage in this kind of solution.
–
–
–
–
TL;DR
If you care about performance, define a function that uses a for-loop.
function sum(arr) {
var res = 0;
for (var x of arr) {
res += x;
return res;
Benchmark
I benchmarked a selection of implementations using benchmark.js (typescript version):
const arr = Array.from({ length: 100 }, () => Math.random());
const reducer = function (p: number, a: number) {
return p + a;
const recursion = function (arr: number[], i: number) {
if(i > 0) return arr[i] + recursion(arr, i - 1)
else return 0
const recursion2 = function (arr: number[], i: number, len: number) {
if(i < len) return arr[i] + recursion2(arr, i + 1, len)
else return 0
const recursion3 = function (arr: number[], i: number) {
if(i < arr.length) return arr[i] + recursion3(arr, i + 1)
else return 0
new Benchmark.Suite()
.add("jquery", () => {
let res = 0;
$.each(arr, (_, x) => (res += x));
.add("lodash", ()=>_.sum(arr))
.add("forEach", () => {
let res = 0;
arr.forEach((x) => (res += x));
.add("reduce", () => arr.reduce((p, a) => p + a, 0))
.add("predefined reduce", () => arr.reduce(reducer, 0))
.add("eval", () => eval(arr.join("+")))
.add("recursion", () => recursion(arr, arr.length - 1))
.add("recursion2", () => recursion2(arr, 0, arr.length))
.add("recursion3", () => recursion3(arr, 0))
.add("naive", () => (
arr[0]+arr[1]+arr[2]+arr[3]+arr[4]+arr[5]+arr[6]+arr[7]+arr[8]+arr[9]+
arr[10]+arr[11]+arr[12]+arr[13]+arr[14]+arr[15]+arr[16]+arr[17]+arr[18]+arr[19]+
arr[20]+arr[21]+arr[22]+arr[23]+arr[24]+arr[25]+arr[26]+arr[27]+arr[28]+arr[29]+
arr[30]+arr[31]+arr[32]+arr[33]+arr[34]+arr[35]+arr[36]+arr[37]+arr[38]+arr[39]+
arr[40]+arr[41]+arr[42]+arr[43]+arr[44]+arr[45]+arr[46]+arr[47]+arr[48]+arr[49]+
arr[50]+arr[51]+arr[52]+arr[53]+arr[54]+arr[55]+arr[56]+arr[57]+arr[58]+arr[59]+
arr[60]+arr[61]+arr[62]+arr[63]+arr[64]+arr[65]+arr[66]+arr[67]+arr[68]+arr[69]+
arr[70]+arr[71]+arr[72]+arr[73]+arr[74]+arr[75]+arr[76]+arr[77]+arr[78]+arr[79]+
arr[80]+arr[81]+arr[82]+arr[83]+arr[84]+arr[85]+arr[86]+arr[87]+arr[88]+arr[89]+
arr[90]+arr[91]+arr[92]+arr[93]+arr[94]+arr[95]+arr[96]+arr[97]+arr[98]+arr[99]))
.add("loop with iterator", () => {
let res = 0;
for (const x of arr) res += x;
.add("traditional for loop", () => {
let res = 0;
// cache the length in case the browser can't do it automatically
const len = arr.length;
for (let i = 0; i < len; i++) res += arr[i];
.add("while loop", () => {
let res = 0;
let i = arr.length;
while (i--) res += arr[i];
.add("loop in a function ", () => sum(arr))
.on("cycle", (event) => console.log(String(event.target)))
.run();
In chrome 104, the for-loop-based implementations are the fastest:
jquery x 1,832,472 ops/sec ±1.35% (61 runs sampled)
lodash x 2,079,009 ops/sec ±1.11% (68 runs sampled)
forEach x 4,887,484 ops/sec ±2.35% (67 runs sampled)
reduce x 21,762,391 ops/sec ±0.46% (69 runs sampled)
predefined reduce x 2,026,411 ops/sec ±0.50% (68 runs sampled)
eval x 33,381 ops/sec ±2.54% (66 runs sampled)
recursion x 2,252,353 ops/sec ±2.13% (62 runs sampled)
recursion2 x 2,301,516 ops/sec ±1.15% (65 runs sampled)
recursion3 x 2,395,563 ops/sec ±1.65% (66 runs sampled)
naive x 31,244,240 ops/sec ±0.76% (66 runs sampled)
loop with iterator x 29,554,762 ops/sec ±1.07% (66 runs sampled)
traditional for loop x 30,052,685 ops/sec ±0.67% (66 runs sampled)
while loop x 18,624,045 ops/sec ±0.17% (69 runs sampled)
loop in a function x 29,437,954 ops/sec ±0.54% (66 runs sampled)
Firefox 104 shows similar behaviour:
jquery x 1,461,578 ops/sec ±1.58% (64 runs sampled)
lodash x 4,931,619 ops/sec ±0.80% (66 runs sampled)
forEach x 5,594,013 ops/sec ±0.51% (68 runs sampled)
reduce x 3,731,232 ops/sec ±0.53% (66 runs sampled)
predefined reduce x 2,633,652 ops/sec ±0.54% (66 runs sampled)
eval x 105,003 ops/sec ±0.88% (66 runs sampled)
recursion x 1,194,551 ops/sec ±0.24% (67 runs sampled)
recursion2 x 1,186,138 ops/sec ±0.20% (68 runs sampled)
recursion3 x 1,191,921 ops/sec ±0.24% (68 runs sampled)
naive x 21,610,416 ops/sec ±0.66% (66 runs sampled)
loop with iterator x 15,311,298 ops/sec ±0.43% (67 runs sampled)
traditional for loop x 15,406,772 ops/sec ±0.59% (67 runs sampled)
while loop x 11,513,234 ops/sec ±0.60% (67 runs sampled)
loop in a function x 15,417,944 ops/sec ±0.32% (68 runs sampled)
Discussion
Implementations defining an anonymous function are generally slower because creating an anonymous function is a significant overhead. When running the benchmark with a large array, e.g., with length 1000 instead of 100, the difference between reduce and the for-loop-based implementations becomes insignificant in chrome.
Chrome's V8 engine knows how to inline simple anonymous functions in reduce since the reduce test case is much faster than the predefined reduce test case. Firefox seems to try something similar but is less efficient in doing so. Non-inlined function calls are pretty slow in js since the call stack is less efficient than the call stack in compiled software.
Similar to reduce, the forEach- and jquery-based implementations use anonymous functions and are relatively slow. lodash has a specialized sum implementation, but it is (as of v4.0.0) implemented as a special case of sumBy, which is relatively inefficient.
eval is the by far slowest test case. This makes sense since constructing the string using concatenations might cause several dynamic allocations (which are slow). Next, the parser has to be invoked and only then can the code be finally executed.
I've included some recursive implementations because some people on the internet claim that recursion is faster than loops in js. I can't reproduce their example - using benchmark.js, recursion is very slow, and when using console.time with a loop, both functions take the same time. When calculating the sum, as expected, recursion is much slower than loops, probably due to intense usage of the js call stack.
The naive implementation would be manually adding all 100 elements of the array. While being quite inconvenient, this is the fastest implementation. But, luckily, for-loops come very close. Adding a single function call around the loop doesn't harm the performance. Therefore, you can feel free to use the utility function from above.
I have no explanation why the while loop is slower than the for loop. Iterating the array in reverse doesn't seem to be the problem here.
I am a beginner with JavaScript and coding in general, but I found that a simple and easy way to sum the numbers in an array is like this:
var myNumbers = [1,2,3,4,5]
var total = 0;
for(var i = 0; i < myNumbers.length; i++){
total += myNumbers[i];
Basically, I wanted to contribute this because I didn't see many solutions that don't use built-in functions, and this method is easy to write and understand.
–
const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);
console.log(result); // Should give 100
A few people have suggested adding a .sum() method to the Array.prototype. This is generally considered bad practice so I'm not suggesting that you do it.
If you still insist on doing it then this is a succinct way of writing it:
Array.prototype.sum = function() {return [].reduce.call(this, (a,i) => a+i, 0);}
then: [1,2].sum(); // 3
Note that the function added to the prototype is using a mixture of ES5 and ES6 function and arrow syntax. The function is declared to allow the method to get the this context from the Array that you're operating on. I used the => for brevity inside the reduce call.
–
That way you can put all kinds of exotic things in the array.
var arr = ['(1/3)','Date.now()','foo','bar()',1,2,3,4]
I'm only half joking.
No need to initial value! Because if no initial value is passed, the callback function is not invoked on the first element of the list, and the first element is instead passed as the initial value. Very cOOl feature :)
[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
Here's an elegant one-liner solution that uses stack algorithm, though one may take some time to understand the beauty of this implementation.
const getSum = arr => (arr.length === 1) ? arr[0] : arr.pop() + getSum(arr);
getSum([1, 2, 3, 4, 5]) //15
Basically, the function accepts an array and checks whether the array contains exactly one item. If false, it pop the last item out of the stack and return the updated array.
The beauty of this snippet is that the function includes arr[0] checking to prevent infinite looping. Once it reaches the last item, it returns the entire sum.
Accuracy
Sort array and start sum form smallest numbers (snippet shows difference with nonsort)
[...arr].sort((a,b)=>a-b).reduce((a,c)=>a+c,0)
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]
Is there a reason not to just filter the array first to remove non-numbers? Seems simple enough:
[1, 2, 3, null, 'a'].filter((x) => !isNaN(x)).reduce((a, b) => a + b)
Those are really great answers, but just in case if the numbers are in sequence like in the question ( 1,2,3,4) you can easily do that by applying the formula
(n*(n+1))/2 where n is the last number
–
Simplest answer to understand underlying process:
let array = [10, 20, 30, 40, 50]
let total = 0
for(let i in array)
total += array[i]
console.log(total)
& if you're already familiar with underlying process then built-in method can save you time:
let array = [10, 20, 30, 40, 50]
let total = array.reduce((x, y) => x + y)
console.log(total)
