Here's a more refined solution in my opinion:

const total = numbers.reduce((prev, curr) => prev + curr, 0);
const average = (total / numbers.length) || 0;

console.log(`Total sum: ${total}. Average value: ${average}.`);

ES6 Functions

function calcAverage(arr) {
    const sum = arr.reduce( (prev, curr) => prev + curr, 0);
    return sum / arr.length;
}

const numbers = [3, 5, 7, 9];
const avg = calcAverage(numbers);
    
console.log(avg);

Here is a simple method to calculate the average (mean) using the reduce function and ES6 syntax:

const getAverage = data => data.reduce((previous, current) => previous + current) / data.length;

const dataPoints = [2, 4, 6, 8];
getAverage(dataPoints); // Output: 5

Most concise way to calculate the Average

const avgCalc = arr => arr.reduce((acc,v,i,a)=>(acc+v/a.length),0);

Simplest method to find the Sum

const sumCalc = arr => arr.reduce((a,b)=>a+b);

Imagine having an array of integers:

const values = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

To calculate the average, we use this formula:

A= (1/n)Σxi ( where i = 1 to n ) ... In other words: x1/n + x2/n + ... + xn/n

We divide the current value by the total number of values and add it to the sum of previous results.

The signature for the reduce method is as follows:

reduce(callback[,default_previous_value])

The callback function in reduce accepts these parameters:

• p : Result of the previous calculation
• c : Current value (from the current index)
• i : Index value of the current array element
• a : The current reduced Array

The default value for the second parameter in reduce is used when the array is empty.

Thus, the average using reduce method can be calculated like this:

const avg = values.reduce(function(p,c,i,a){return p + (c/a.length)},0);

You may also create separate functions:

function average(p,c,i,a){return p + (c/a.length)};
function sum(p,c){return p + c)};

And reference them in reduce method like so:

const avg = values.reduce(average,0);
const sum = values.reduce(sum,0);

Alternatively, you can extend the Array prototype directly:

Array.prototype.sum = Array.prototype.sum || function (){
  return this.reduce(function(p,c){return p+c},0);
};

Each time reduce method is called, dividing the value is possible:

Array.prototype.avg = Array.prototype.avg || function () {
  return this.reduce(function(p,c,i,a){return p+(c/a.length)},0);
};

Or better yet, utilizing the previously defined Array.protoype.sum()

to optimize the process by performing division only once:

Array.prototype.avg = Array.prototype.avg || function () {
  return this.sum()/this.length; 
};

Then on any Array object within the scope:

[2, 6].avg();// -> 4
[2, 6].sum();// -> 8

Note: An empty array will yield NaN which can be more accurate than 0 in specific cases.

usually when using a one-liner reduce, the code looks like this

elements.reduce(function(sum, a,i,ar) { sum += a;  return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);

specially tailored to the specific question posed

elements.reduce(function(sum, a,i,ar) { sum += parseFloat(a);  return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);

a more efficient version would be

elements.reduce(function(sum, a) { return sum + a },0)/(elements.length||1);

Quickly grasp JavaScript Array Reduce in just 1 Minute

as brought up by gotofritz, it seems that Array.reduce skips undefined values. so here is a solution:

(function average(arr){var finalstate=arr.reduce(function(state,a) { state.sum+=a;state.count+=1; return state },{sum:0,count:0}); return finalstate.sum/finalstate.count})([2,,,6])

If you're looking to streamline your Math operations, consider utilizing the lodash library for functions like _.sum(array) and _.mean(array), which offer added convenience.

_.sum([4, 2, 8, 6]);
// => 20
_.mean([4, 2, 8, 6]);
// => 5

For browsers that are ready for ES6, this polyfill can be quite useful.

Math.sum = (...a) => Array.prototype.reduce.call(a,(a,b) => a+b)

Math.avg = (...a) => Math.sum(...a)/a.length;

You can use the same method call for Math.sum, Math.avg, and Math.max, like this

var maxOne = Math.max(1,2,3,4) // 4;

When using Math.sum:

var sumNum = Math.sum(1,2,3,4) // 10

Or if you need to sum up an array:

var sumNum = Math.sum.apply(null,[1,2,3,4]) // 10

Similarly,

var maxOne = Math.max.apply(null,[1,2,3,4]) // 4

Although not the most efficient solution in terms of speed, a concise one-liner method can be achieved by utilizing the map() and reduce() functions:

const average = [7, 14, 21].map((number) => number / 3).reduce((total, current) => total + current);

These are the functions I have added to my personal JavaScript library:

Array.prototype.sum = Array.prototype.sum || function() {
  return this.reduce(function(sum, a) { return sum + Number(a) }, 0);
}

Array.prototype.average = Array.prototype.average || function() {
  return this.sum() / (this.length || 1);
}

UPDATE: You can use these functions by simply calling them on an array to calculate its sum or average, for example:

[1,2,3].sum() // = 6
[1,2,3].average() // = 2

Here's a clever trick you could use, although it does involve using the infamous eval() function.

var sum = eval(elmt.join('+')), avg = sum / elmt.length;
document.write("The total sum of all elements is: " + sum + ". The average of all elements is: " + avg + "<br/>");

I thought I'd share this as a unique 'out-of-the-box' solution. Sometimes thinking outside the norm can lead to unexpected outcomes.

Check out this neat modification to the “Math” object in JavaScript that adds an "average" command!

Math.average = function(input) {
  this.result = 0;
  for (this.i = 0; this.i < input.length; this.i++) {
    this.result += Number(input[this.i]);
  }
  return this.result / input.length;
}

In addition, here's another extension to the “Math” object for finding the sum.

Math.sum = function(input) {
  this.output = 0;
  for (this.i = 0; this.i < input.length; this.i++) {
    this.output += Number(input[this.i]);
  }
  return this.output;
}

To use these functions, simply do:

alert(Math.sum([5,5,5])); //alerts “15”
alert(Math.average([10,0,5])); //alerts “5”

You can replace the placeholder arrays with your own variables as inputs (they can be strings if they are numbers because the function will parse them into numbers)!

After testing various methods, I stumbled upon Sergi Mansilla's brilliant solution which ensures that float summation is performed instead of string concatenation by utilizing the parseFloat() function:

let sum = ourarray.reduce((a, b) => parseFloat(a) + parseFloat(b), 0);
let avg = (sum / ourarray.length) || 0;

console.log(sum); // display total sum
console.log(avg); // display average

Change the starting value of your for loop counter to 0. You are currently only fetching element 9 before ending the loop, while the rest are simply basic mathematical solutions. Consider using a variable to hold the sum (remember to convert strings to integers) and then divide by the length of your array.

To start off, we define all the variables that will be used in our code. Notice how I am using the literal notation [] for the numbers array instead of the constructor method array(). I also have a concise way of setting multiple variables to 0.

var numbers = [], count = sum = avg = 0;

Next step involves filling up the empty numbers array with values from 0 to 11 to reach the initial starting point. Pay attention to how I'm incrementing count while pushing onto the array.

while ( count < 12 )
    numbers.push( count++ );

Finally, I iterate through each number in the numbers array using a "for each" function. This function processes one number at a time and is represented as "n" within its body.

numbers.forEach(function(n){
  sum += n; 
  avg = sum / numbers.length;
});

At the end of it all, we can display both the sum value and the avg value on the console to see the result:

// Sum: 66, Avg: 5.5
console.log( 'Sum: ' + sum + ', Avg: ' + avg );

View the live action online at http://jsbin.com/unukoj/3/edit

Expanding on the response from Abdennour TOUMI, here are my thoughts:

1.) I concur with Brad's point that extending objects we did not create may not be advisable.

2.) Using array.length in JavaScript can be unreliable; I personally prefer using Array.reduce because of scenarios like a=[1,3];a[1000]=5;, where a.length would return 1001.

function getAverage(arry){
    // check if array
    if(!(Object.prototype.toString.call(arry) === '[object Array]')){
        return 0;
    }
    var sum = 0, count = 0; 
    sum = arry.reduce(function(previousValue, currentValue, index, array) {
        if(isFinite(currentValue)){
            count++;
            return previousValue+ parseFloat(currentValue);
        }
        return previousValue;
    }, sum);
    return count ? sum / count : 0; 
};

Function to Calculate Average of an Array with Optional Mapper Function:

Array.prototype.avg=function(fn){
    fn =fn || function(e,i){return e};
    return (this.map(fn).reduce(function(a,b){return parseFloat(a)+parseFloat(b)},0) / this.length ) ; 
};

Usage Examples:

[10, 20, 30].avg() ;  //-> OUTPUT : 20

[{price:50},{price:60},{price:70}].avg(function(e){return e.price}); // OUTPUT : 60

Arrow functions are supported on evergreen browsers, making them a convenient option to use.

avg = [1,2,3].reduce((a,b) => (a+b);

After running the code 100,000 times, the difference in execution time between using a for loop and the reduce method is minimal.

s=Date.now();for(i=0;i<100000;i++){ n=[1,2,3]; a=n.reduce((a,b) => (a+b)) / n.length };
console.log("100k reduce took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<100000;i++){n=[1,2,3]; nl=n.length; a=0; for(j=nl-1;j>0;j--){a=a+n[j];} a/nl };
console.log("100k for loop took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<1000000;i++){n=[1,2,3]; nl=n.length; a=0; for(j=nl-1;j>0;j--){a=a+n[j];} a/nl };
console.log("1M for loop took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<1000000;i++){ n=[1,2,3]; a=n.reduce((a,b) => (a+b)) / n.length };
console.log("1M reduce took " + (Date.now()-s) + "ms.");

/* 
 * RESULT on Chrome 51
 * 100k reduce took 26ms.
 * 100k for loop took 35ms.
 * 10M for loop took 126ms.
 * 10M reduce took 209ms.
 */

If you find yourself needing the average and want to avoid calculating the sum, there is a simple way to compute the average using just one reduce function call:

// Assuming an array contains only values that can be converted to a Float
var reducer = function(cumulativeAverage, currentValue, currentIndex) {
  // 1. Multiply the current average by the current index to calculate cumulative sum of previous elements
  // 2. Add the current value to get the cumulative sum including the current element
  // 3. Divide by the total number of elements including the current element (zero-based index + 1)
  return (cumulativeAverage * currentIndex + parseFloat(currentValue))/(currentIndex + 1)
}
console.log([1, 2, 3, 4, 5, 6, 7, 8, 9, 10].reduce(reducer, 0)); // => 5.5
console.log([].reduce(reducer, 0)); // => 0
console.log([0].reduce(reducer, 0)); // => 0
console.log([].reduce(reducer, 0)); // => 0
console.log([,,,].reduce(reducer, 0)); // => 0
console.log([].reduce(reducer, 0)); // => 0

If you ever find yourself in need, here's a clever recursive average calculation method.

In the given scenario, utilizing the recursive average can be beneficial if you allow users to input more values and wish to "update" the current average without having to revisit each element again.

/**
 * Computes the recursive average of an indefinite set
 * @param {Iterable<number>} set iterable sequence to average
 * @param {number} initAvg initial average value
 * @param {number} initCount initial average count
 */
function average(set, initAvg, initCount) {
  if (!set || !set[Symbol.iterator])
    throw Error("must pass an iterable sequence");

  let avg = initAvg || 0;
  let avgCnt = initCount || 0;
  for (let x of set) {
    avgCnt += 1;
    avg = avg * ((avgCnt - 1) / avgCnt) + x / avgCnt;
  }
  return avg; // or {avg: avg, count: avgCnt};
}

average([2, 4, 6]);    //returns 4
average([4, 6], 2, 1); //returns 4
average([6], 3, 2);    //returns 4
average({
  *[Symbol.iterator]() {
    yield 2; yield 4; yield 6;
  }
});                    //returns 4

How:

This algorithm works by maintaining the existing average and element count. Whenever a new value is added, it increases the count by 1, adjusts the previous average using (count-1) / count, and incorporates newValue / count into the updated average.

Benefits:

• Avoids summing all elements, preventing overflow issues with large numbers that exceed storage capabilities of a 64-bit float.
• Allows updating of an existing average when additional values are introduced.
• Enables continual averaging without requiring knowledge of the sequence length.

Downsides:

• Increases the number of division operations needed
• Has a limitation on Number.MAX_SAFE_INTEGER items unless utilizing BigNumber library

After reviewing the other options, I have decided to simplify the code for future viewers by elaborating on the existing code rather than creating a more elegant solution. Instead of declaring the numbers as strings and using parseInt, we can utilize the following method:

const numberConverter = elmt.map(Number);

The map function creates a copy of the original array but converts its values to numbers. We can then employ the reduce method to compute the sum (which could be simplified further, but I am opting for clarity and also demonstrating two different average calculation methods). The reduce method uses an accumulator that accumulates values as it iterates through the array and adds the currentValue to it:

var i;
const elmt = new Array();
elmt[0] = '0';
elmt[1] = '1';
elmt[2] = '2';
elmt[3] = '3';
elmt[4] = '4';
elmt[5] = '7';
elmt[6] = '8';
elmt[7] = '9';
elmt[8] = '10';
elmt[9] = '11';

console.log(elmt);

const numberConverter = elmt.map(Number);

const sum = numberConverter.reduce((accumulator, currentValue) => {
  return accumulator + currentValue;
}, 0);

const average = numberConverter.reduce(
  (accumulator, currentvalue, index, numArray) => {
    return accumulator + currentvalue / numArray.length;
  },
  0
);

const average2 =
  numberConverter.reduce(
    (accumulator, currentValue) => accumulator + currentValue,
    0
  ) / numberConverter.length;

for (i = 9; i < 10; i++) {
  console.log(
    `The sum of all the elements is: ${sum}. <br> The average of all the elements is: ${average2}`
  );}

It seems like all previous solutions have relied on the length of the list to calculate the average by summing up the values.

However, there is a drawback to this method that can be addressed with a slightly modified yet still simple algorithm.

The issue lies in assuming that there will not be an overflow when adding up all the numbers. If the numbers are significantly large and added together, they may surpass the maximum size allowed for the data type.

A more effective approach would be to calculate the average as you iterate through the list, rather than summing everything up and then dividing at the end:

function getAvg(values) {
    return values.reduce((m, x, i) => m + (x - m) / (i + 1), 0)
}

Credit goes to Knuth's "Art of Computer Programming" volume 2.

This is purely for entertainment

const average = [12, 34, -9, 67, 45].reduce((accum, elem, index) => (accum*index+elem)/(index+1));

console.log(average)

Just for fun:

let elements = [5, 8, 13, 21, 34, 55], totalSum = 0;
for (let i = 0; i < elements.length; i++) {
    totalSum += elements[i];
}
document.body.appendChild(document.createTextNode('The sum of all elements is: ' + totalSum + '. The average of all elements is: ' + (totalSum / elements.length)));

Here is a potential solution:

let sum = elements.reduce((a, b) => parseFloat(a) + parseFloat(b));
let average = sum / elements.length;
console.log(average);

I included parseFloat twice in the code for two reasons:

1) If you add the number (a)9 and string ("1"), the result will be "91". To avoid this, I used parseFloat.

2) When adding the number (a)9 and the parsed float of("1"), the result will still be "10", but as a string. To prevent this, I used parseFloat again.

I hope this clarifies things. Any suggestions are appreciated!

Sharing my beginner's method for quickly calculating an average. Maybe this will benefit someone.

function findAverage(numbers){
    var sum = 0;
    for(var i = 0; i < numbers.length; i++) { 
        sum += numbers[i];
    }
    return sum / numbers.length;
}

Presenting to you a concise solution:

let average = arr.reduce((sum, item, index, arr) => index !== arr.length-1 ? sum + item : sum + item/arr.length, 0)

This code snippet offers a straightforward approach to calculating the average using a for loop and a function.

var elements = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

function calculateAverage(array) {
    var totalSum = 0;
    for (var index = 0; index < array.length; index++) {
        totalSum += array[index];
    }
    console.log(Math.round(totalSum/array.length));
}

calculateAverage(elements);

There appears to be a multitude of solutions available, but I have come across one that is both succinct and elegant.

const numbers = [1, 2, 3, 4];
const count = numbers.length;
const reducer = (adder, value) => (adder + value);
const average = numbers.map(x => x / count).reduce(reducer);
console.log(average); // 2.5

Alternatively:

const numbers = [1, 2, 3, 4];
const average = numbers.map(x => x / numbers.length).reduce((adder, value) => (adder + value));
console.log(average); // 2.5

If you encounter issues with arrow functions in your browser, consider using explicit function calls:

const r = function(adder, value) {
    return adder + value;
};
const m = function(x) {
    return x / count;
};
const average = numbers.map(m).reduce(r);
console.log(average); // 2.5

Another option would be:

const average1 = numbers
    .map(function(x) {
        return x / count;
     })
    .reduce(function(adder, value) {
        return adder + value;
});
console.log(average1);