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.

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

You get a TypeError

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

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

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

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.

In Lisp, this'd be exactly the job for `reduce`

. You'd see this kind of code:

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

Fortunately, in JavaScript, we also have `reduce`

! Unfortunately, `+`

is an operator, not a function. But we can make it pretty! Here, look:

```
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? :-)

Even better! If you're using ECMAScript 2015 (aka ECMAScript 6), it can be this pretty:

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

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

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

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

If you happen to be using Lodash you can use the sum function

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

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

This will take on average 1.57 ms/run (measured over 1000 runs on an array of 100 random normal numbers), compared to 3.604 ms/run with the `eval()`

method above and 2.151 ms/run with a standard for(i,length,++) loop.

Methodology note: this test was run on a Google Apps Script server, so their javascript engines are pretty much the same as Chrome.

EDIT: `--i`

instead of `i--`

saves 0.12 ms each run (i-- is 1.7)

EDIT: Holy expletive, never mind this whole post. **Use the reduce() method mentioned above, it's only 1 ms/run.**

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

Anyone looking for a functional oneliner like me? Take this:

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

Funny approach:

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

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

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.

```
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.

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.

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

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.

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.

You can combine reduce() method with lambda expression:

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

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(sum); // 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:

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

Use `reduce`

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

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 c**OO**l 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
```

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

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.

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

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

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

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

**Increase Accuracy**: sort array and start sum form smallest numbers

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

```
arr=[.6,9,.1,.1,.1,.1]
sum = arr.reduce((a,c)=>a+c,0)
sortSum = [...arr].sort().reduce((a,c)=>a+c,0)
console.log('sum: ',sum);
console.log('sortSum:',sortSum);
console.log('sum==sortSum :', sum==sortSum);
```

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

©2020 All rights reserved.