How to find the sum of an array of numbers
JavascriptJqueryArraysJavascript Problem Overview
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.
Javascript Solutions
Solution 1 - Javascript
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? :-)
Solution 2 - Javascript
Recommended (reduce with default value)
Array.prototype.reduce can be used to iterate through the array, adding the current element value to the sum of the previous element values.
console.log(
[1, 2, 3, 4].reduce((a, b) => a + b, 0)
)
console.log(
[].reduce((a, b) => a + b, 0)
)
Without default value
You get a TypeError console.log( [].reduce((a, b) => a + b) )
Prior to ES6's arrow functions
console.log( [1,2,3].reduce(function(acc, val) { return acc + val; }, 0) )
console.log(
[].reduce(function(acc, val) { return acc + val; }, 0)
)
Non-number inputs
If non-numbers are possible inputs, you may want to handle that?
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))
)
Non-recommended dangerous eval use
We can use eval to execute a string representation of JavaScript code. Using the Array.prototype.join function to convert the array to a string, we change [1,2,3] into "1+2+3", which evaluates to 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('+'))
Of course displaying an alert isn't the worst thing that could happen. The only reason I have included this is as an answer Ortund's question as I do not think it was clarified.
Solution 3 - Javascript
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);
Solution 4 - Javascript
var arr = [1, 2, 3, 4];
var total = 0;
for (var i in arr) {
total += arr[i];
}
Solution 5 - Javascript
var total = 0;
$.each(arr,function() {
total += this;
});
Solution 6 - Javascript
If you happen to be using Lodash you can use the sum function
array = [1, 2, 3, 4];
sum = _.sum(array); // sum == 10
Solution 7 - Javascript
Anyone looking for a functional oneliner like me?
Assuming:
const arr = [1, 2, 3, 4];
Here's the oneliner for modern JS:
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.
Solution 8 - Javascript
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 (
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;
}
Solution 9 - Javascript
arr.reduce(function (a, b) {
return a + b;
});
Reference: Array.prototype.reduce()
Solution 10 - Javascript
OK, imagine you have this array below:
const arr = [1, 2, 3, 4];
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...
Solution 11 - Javascript
Funny approach:
eval([1,2,3].join("+"))
Solution 12 - Javascript
You can also use reduceRight.
[1,2,3,4,5,6].reduceRight(function(a,b){return a+b;})
which results output as 21.
Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
Solution 13 - Javascript
A standard JavaScript solution:
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 */
This works for me (the result should be 5). I hope there is no hidden disadvantage in this kind of solution.
Solution 14 - Javascript
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.
Solution 15 - Javascript
Use a for
loop:
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
Or even a forEach
loop:
const array = [1, 2, 3, 4];
let result = 0;
array.forEach(number => {
result += number;
})
console.log(result); // Should give 10
For simplicity, use reduce
:
const array = [10, 20, 30, 40];
const add = (a, b) => a + b
const result = array.reduce(add);
console.log(result); // Should give 100
Solution 16 - Javascript
var totally = eval(arr.join('+'))
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.
Solution 17 - Javascript
ES6 for..of
let total = 0;
for (let value of [1, 2, 3, 4]) {
total += value;
}
Solution 18 - Javascript
A short piece of JavaScript code would do this job:
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)
Solution 19 - Javascript
Use reduce
let arr = [1, 2, 3, 4];
let sum = arr.reduce((v, i) => (v + i));
console.log(sum);
Solution 20 - Javascript
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.
Solution 21 - Javascript
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
Solution 22 - Javascript
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.
Solution 23 - Javascript
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)
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]
For multidimensional array of numbers use 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
Solution 24 - Javascript
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
Solution 25 - Javascript
You can combine reduce() method with lambda expression:
[1, 2, 3, 4].reduce((accumulator, currentValue) => accumulator + currentValue);
Solution 26 - Javascript
With reduce()
[1, 2, 3, 4].reduce((a, b) => a + b, 0); // 10
With forEach()
let sum = 0;
[1, 2, 3, 4].forEach(n => sum += n);
sum; // 10
With Parameter
function arrSum(arr) {
sum = 0;
arr.forEach(n => sum += n);
return sum;
}
arrSum([1, 2, 3, 4]) // 10
Solution 27 - Javascript
i saw all answers going for 'reduce' solution
var array = [1,2,3,4]
var total = 0
for (var i = 0; i < array.length; i++) {
total += array[i]
}
console.log(total)
Solution 28 - Javascript
very simple
step 1 we should have an array like :
const arrayNumber = [500,152,154,1555,12445];
step 2 (you can ignore this step if) step is to be sur that all values in table are number for that
let newArray = [];
for (let i = 0; i < arrayNumber.length; i++) {
newArray.push(parseInt(arrayNumber[i], 10));
}
step 3
const sumInArray = dataData.reduce( (a, b) => a + b);
finally
console.log(sumInArray);
Solution 29 - Javascript
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)
Solution 30 - Javascript
Cool tricks here, I've got a nit pick with a lot of the safe traditional answers not caching the length of the array.
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 ) );
Without caching the length of the array the JS compiler needs to go through the array with every iteration of the loop to calculate the length, it's unnecessary overhead in most cases. V8 and a lot of modern browsers optimize this for us, so it is less of a concern then it was, but there are older devices that benefit from this simple caching.
If the length is subject to change, caching's that could cause some unexpected side effects if you're unaware of why you're caching the length, but for a reusable function who's only purpose is to take an array and add the values together it's a great fit.
Here's a CodePen link for this arraySum function. http://codepen.io/brandonbrule/pen/ZGEJyV
It's possible this is an outdated mindset that's stuck with me, but I don't see a disadvantage to using it in this context.
Solution 31 - Javascript
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
Solution 32 - Javascript
This is much easier
function sumArray(arr) {
var total = 0;
arr.forEach(function(element){
total += element;
})
return total;
}
var sum = sumArray([1,2,3,4])
console.log(sum)
Solution 33 - Javascript
With ES6 rest parameter
let array = [1, 2, 3, 4]
function sum(...numbers) {
let total = 0;
for (const number of numbers) {
total += number;
}
return total;
}
console.log(sum(...array));
Solution 34 - Javascript
A simple method example:
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]));
Solution 35 - Javascript
When the array consists of strings one has to alter the code. This can be the case, if the array is a result from a databank request. This code works:
alert(
["1", "2", "3", "4"].reduce((a, b) => Number(a) + Number(b), 0)
);
Here, ["1", "2", "3", "4"] ist the string array and the function Number()
converts the strings to numbers.
Solution 36 - Javascript
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)
Solution 37 - Javascript
You can try the following code:
[1, 2, 3, 4].reduce((pre,curr)=>pre+curr,0)
Solution 38 - Javascript
try this...
function arrSum(arr){
total = 0;
arr.forEach(function(key){
total = total + key;
});
return total;
}
Solution 39 - Javascript
Vanilla JavaScript is all you need:
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(function(e){sum += e}); sum
10
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; a.forEach(e => sum += e); sum
10
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; for(e in a) sum += e; sum
"00123foobar"
> a = [1,2,3,4]; a.foo = 5; a['bar'] = 6; sum = 0; for(e of a) sum += e; sum
10
Solution 40 - Javascript
This function can sum up all the numbers -
function array(arr){
var sum = 0;
for (var i = 0; i< arr.length; i++){
sum += arr[i];
}
console.log(sum);
}
array([5, 1, 3, 3])
Solution 41 - Javascript
Considering you have the array
const arr = [1, 2, 3, 4];
For me, the most intuitive way is using a for-in
let sum = 0;
for(var value in arr) {
sum += arr[value];
}
console.log('Array:', arr);
console.log('Sum:', sum);
Yet, you can also use Arrow Functions and the reduce function
const sum = arr.reduce(function (a, b) {
return a + b;
}, 0);
console.log('Array:', arr);
console.log('Sum:', sum);
They're both gonna output
Array: [ 1, 2, 3, 4]
Sum: 10
Solution 42 - Javascript
getTotal = (arr) => {
let total = 0
for (let i = 0; i < arr.length; i++) {
total += arr[i];
}
return total
}
getTotal([1, 2, 3, 4]) // 10
getTotal([1, 2, 3, 4, 5]) // 15
Solution 43 - Javascript
Just use this function:
function sum(pArray)
{
pArray = pArray.reduce(function (a, b) {
return a + b;
}, 0);
return pArray;
}
function sum(pArray)
{
pArray = pArray.reduce(function (a, b) {
return a + b;
}, 0);
return pArray;
}
var arr = [1, 4, 5];
console.log(sum(arr));
Solution 44 - Javascript
A "duplicate" question asked how to do this for a two-dimensional array, so this is a simple adaptation to answer that question. (The difference is only the six characters [2], 0
, which finds the third item in each subarray and passes an initial value of zero):
const twoDimensionalArray = [
[10, 10, 1],
[10, 10, 2],
[10, 10, 3],
];
const sum = twoDimensionalArray.reduce( (partial_sum, a) => partial_sum + a[2], 0 ) ;
console.log(sum); // 6
Solution 45 - Javascript
You can try this:
var arr = [100,114,250,1200];
var total = 0;
for(var i in arr){
total += parseInt(arr[i]);
}
console.log(total);
Output will be: 1664
Or if value is Float, then try this:
var arr = [100.00,114.50,250.75,1200.00];
var total = 0;
for(var i in arr){
total += parseFloat(arr[i]);
}
console.log(total.toFixed(2));
Output will be: 1665.25
Solution 46 - Javascript
I´m aware that this is an old post. But I just wanted to share my approach to the problem.
let myArr = [1, 3, 4, 5, 6, 7, 8];
let counter = 0;
for(let i = 0; i < myArr.length; i++){
counter = counter + myArr[i];
console.log(counter);}
Solution 47 - Javascript
//Try this way
const arr = [10,10,20,60];
const sumOfArr = (a) =>{
let sum=0;
for(let i in a) {
sum += a[i];
}
return sum;
}
console.log(sumOfArr(arr))
Solution 48 - Javascript
Someone also can use map()
function for the summation of an array values.
function sumOfArrVal(arr){
let sum=0;
arr.map(val=>sum+=val)
return sum
}
let result=sumOfArrVal([1,2,3,4])
console.log(result)
Solution 49 - Javascript
The truth is there is an old and funny classic solution (beside newbie 'foreach' and 'reduce'): the classic for of.
y = 0;
for (x of [1, 2, 3, 4]) y+=x;
Solution 50 - Javascript
I see that this is an old question, but hardly any of the answers actually use jQuery and specifically $.each
as requested by the asker. There is a way to do this, but the native approaches as suggested by many (i.e. using Array.reduce()
) are much better and easier.
Here's the jQuery way if you absolutely have to use it:
var arr = [1,2,3,4];
var sum = 0;
$.each( arr, (i, v) => sum += v);
alert(sum); // This will be 10
Solution 51 - Javascript
No one mentioned functional programming, but it would be very clean approach to use Ramda in this case:
//Assuming you use nodejs, but can also be used in browser
const R = require('ramda');
let nums = [2, 4, 6, 8, 10];
console.log(R.sum(nums));
Solution 52 - Javascript
Use recursion
var sum = (arr) => arr.length === 1 ? arr[0] : arr.shift() + sum(arr);
sum([1,2,3,4]) // 10
Solution 53 - Javascript
In addition, sum with es6
for simple array
.
const sum = [1, 2, 3].reduce((partial_sum, a) => partial_sum + a,0);
console.log(sum);
For object array with default initialize value
const totalAmount = obj =>
Object.values(obj).reduce((acc, { order_qty, mrp_price }) =>
acc + order_qty * mrp_price, 0);
console.log(totalAmount);
Solution 54 - Javascript
For really large numbers cycling or reducing could be process intensive. What about using Gauss?
sum = (n * (n+1))/2;
From mathcentral.
Solution 55 - Javascript
<!DOCTYPE html>
<html>
<body>
<p>Click the button to join two arrays.</p>
<button onclick="myFunction()">Try it</button>
<p id="demo"></p>
<script>
var hege = [1, 2,4,6,7,8,8];
var stale = [1, 2,4,5];
function myFunction() {
console.log((hege.length > stale.length))
var children = (hege.length > stale.length)? abc1() :abc2(); document.getElementById("demo").innerHTML = children;
}
function abc1(){
console.log(hege,"Abc1")
var abcd=hege.map(function (num, idx) {
console.log(hege.length , idx)
return stale.length>idx?num + stale[idx]:num;
})
return abcd;
}
function abc2(){
console.log(hege,"Abc2",stale)
var abcd=stale.map(function (num, idx) {
console.log(hege.length , idx)
return hege.length>idx?num + hege[idx]:num;
})
return abcd;
}
</script>
</body>
</html>
Solution 56 - Javascript
Use map
:
var sum = 0;
arr.map(function(item){
sum += item;
});
// sum now contains the total.
You could potentially add the method to the Array prototype.
Array.prototype.sum = function(){
var sum = 0;
this.map(function(item){
sum += item;
});
return sum;
}
Then you can use it on any Array like so:
arr.sum();