Tengo problemas para agregar todos los elementos de una matriz y promediarlos. ¿Cómo haría esto y lo implementaría con el código que tengo actualmente? Se supone que los elementos se definen como lo tengo a continuación.

<script type="text/javascript">
//<![CDATA[

var i;
var 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";

// Problem here
for (i = 9; i < 10; i++){
  document.write("The sum of all the elements is: " + /* Problem here */ + " The average of all the elements is: " + /* Problem here */ + "<br/>");
}   

//]]>
</script>

var sum = 0;
for( var i = 0; i < elmt.length; i++ ){
    sum += parseInt( elmt[i], 10 ); //don't forget to add the base
}

var avg = sum/elmt.length;

document.write( "The sum of all the elements is: " + sum + " The average is: " + avg );

Simplemente recorra la matriz, ya que sus valores son cadenas, primero deben convertirse a un entero. Y el promedio es solo la suma de valores dividida por el número de valores.

Una solución que considero más elegante:

const sum = times.reduce((a, b) => a + b, 0);
const avg = (sum / times.length) || 0;

console.log(`The sum is: ${sum}. The average is: ${avg}.`);

ES6

const average = arr => arr.reduce( ( p, c ) => p + c, 0 ) / arr.length;
    
const result = average( [ 4, 4, 5, 6, 6 ] ); // 5
    
console.log(result);

Cálculo de la media (media) usando reduce y ES6:

const average = list => list.reduce((prev, curr) => prev + curr) / list.length;

const list = [0, 10, 20, 30]
average(list) // 15

en general, el uso promedio de reducción de una línea es así

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

específicamente a la pregunta formulada

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

una versión eficiente es como

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

Comprender la matriz de Javascript Reducir en 1 minuto http://www.airpair.com/javascript/javascript-array-reduce

Como señaló Gotofritz, parece Array.reduce omite valores indefinidos. Así que aquí hay una solución:

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

Imaginemos que tenemos una serie de enteros como este:

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

El promedio se obtiene con la siguiente fórmula

A = (1 / n) Σxi (con i = 1 a n) ... Entonces: x1 / n + x2 / n + ... + xn / n

Dividimos el valor actual por el número de valores y agregamos el resultado anterior al valor devuelto.

La firma del método reduce es

reduce(callback[,default_previous_value])

La función de reducción de devolución de llamada toma los siguientes parámetros:

• p : resultado del cálculo anterior
• c : valor actual (del índice actual)
• i : valor de índice del elemento de matriz actual
• a : La matriz reducida actual

El segundo parámetro de reducción es el valor predeterminado ... (Se usa en caso de que la matriz esté vacía ).

Entonces, el método de reducción promedio será:

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

Si lo prefiere, puede crear una función separada

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

Y luego simplemente consulte la firma del método de devolución de llamada

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

O aumente el prototipo de matriz directamente ...

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

Es posible dividir el valor cada vez que se llama al método de reducción.

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

O incluso mejor , usando el Array.protoype.sum () previamente definido

método, optimice el proceso de llamar a la división solo una vez :)

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

Luego, en cualquier objeto Array del alcance:

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

NB: una matriz vacía con retorno de un deseo NaN es más correcta que 0 en mi punto de vista y puede ser útil en casos de uso específicos.

También puede usar lodash , _.sum (array) y _.mean (array) en la parte Math (también tiene otras cosas convenientes).

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

No es el más rápido, pero el más corto y en una línea está usando map () & reduce ():

var average = [7,14,21].map(function(x,i,arr){return x/arr.length}).reduce(function(a,b){return a + b})

Una manera furtiva de hacerlo es que requiere el uso de (el muy odiado) eval ().

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

Solo pensé en publicar esto como una de esas opciones 'fuera de la caja'. Nunca se sabe, la astucia podría otorgarle (o quitarle) un punto.

Yo uso estos métodos en mi biblioteca personal:

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

EDITAR: Para usarlos, simplemente solicite a la matriz su suma o promedio, como:

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

En navegadores preparados para ES6, este polyfill puede ser útil.

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

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

Puede compartir el mismo método de llamada entre Math.sum, Math.avg y Math.max, como

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

puedes usar Math.sum como

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

o si tiene una matriz para resumir, puede usar

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

al igual que

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

¡Aquí hay una adición rápida al objeto "Math" en javascript para agregarle un comando "promedio"!

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

¡Entonces tengo esta adición al objeto "Matemáticas" para obtener la suma!

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

Entonces todo lo que haces es

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

Y donde puse la matriz de marcador de posición solo paso su variable (¡La entrada si son números puede ser una cadena debido a que se analiza a un número!)

establezca su contador de bucle for en 0 ... está obteniendo el elemento 9 y luego ha terminado como lo tiene ahora. Las otras respuestas son matemáticas básicas. Use una variable para almacenar su suma (necesita convertir las cadenas en ints) y divida por la longitud de su matriz.

Comience definiendo todas las variables que planeamos usar. Notarás que para elnumbers matriz, estoy usando la notación literal de []opuesta al método constructor array(). Además, estoy usando un método más corto para establecer múltiples variables en 0.

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

A continuación, rellenaré mi matriz de números vacíos con los valores del 0 al 11. Esto es para llevarme al punto de partida original. Tenga en cuenta cómo estoy empujando en la matrizcount++ . Esto empuja el valor actual de conteo, y luego lo incrementa para la próxima vez.

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

Por último, estoy realizando una función "para cada" de los números en la matriz de números. Esta función manejará un número a la vez, que estoy identificando como "n" dentro del cuerpo de la función.

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

Al final, podemos generar tanto el sumvalor como elavg valor en nuestra consola para ver el resultado:

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

Véalo en acción en línea en http://jsbin.com/unukoj/3/edit

Solo estoy aprovechando la respuesta de Abdennour TOUMI. Estas son las razones por qué:

1.) Estoy de acuerdo con Brad, no creo que sea una buena idea extender un objeto que no creamos.

2.) array.lengthes exactamente confiable en javascript, prefiero Array.reduceporque a=[1,3];a[1000]=5;ahora a.lengthvolvería 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; 
};

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

Luego :

[ 1 , 2 , 3].avg() ;  //-> OUT : 2

[{age:25},{age:26},{age:27}].avg(function(e){return e.age}); // OUT : 26

En los navegadores de hoja perenne, puede usar las funciones de flecha avg = [1,2,3].reduce((a,b) => (a+b);

Ejecutándolo 100,000 veces, la diferencia de tiempo entre el enfoque for loop y reduce es insignificante.

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

Promedio más corto de un trazador de líneas:

let avg = [1,2,3].reduce((a,v,i)=>(a*i+v)/(i+1));

Sum Shortest One Liner:

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

Sólo por diversión:

var elmt = [0, 1, 2,3, 4, 7, 8, 9, 10, 11], l = elmt.length, i = -1, sum = 0;
for (; ++i < l; sum += elmt[i])
    ;
document.body.appendChild(document.createTextNode('The sum of all the elements is: ' + sum + ' The average of all the elements is: ' + (sum / l)));

Creo que podemos hacer como

var k=elmt.reduce(function(a,b){return parseFloat(a+parseFloat(b));})
var avg=k/elmt.length; 
console.log(avg);

Estoy usando parseFloat dos veces porque cuando 1) agrega (a) 9 + b ("1"), el resultado será "91" pero queremos sumar. así que usé parseFloat

2) Cuando se agrega (a) 9 + parseFloat ("1"), el resultado será "10" pero estará en una cadena que no queremos, así que nuevamente utilicé parseFloat.

Espero estar claro. Sugerencias son bienvenidas

Aquí está mi manera novata de simplemente encontrar el promedio. Espero que esto ayude a alguien.

function numAvg(num){
    var total = 0;
    for(var i = 0;i < num.length; i++) { 
        total+=num[i];
    }
    return total/num.length;
}

Aquí está tu único revestimiento:

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

Creo que esta puede ser una solución directa para calcular el promedio con un bucle y una función.

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

function average(arr) {
    var total = 0;
    for (var i = 0; i < arr.length; i++) {
        total += arr[i];
    }
        console.log(Math.round(total/arr.length));
}

average(elmts);

Parece que hay un sinfín de soluciones para esto, pero me pareció conciso y elegante.

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

O más consistentemente:

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

Dependiendo de su navegador, es posible que necesite hacer llamadas a funciones explícitas porque las funciones de flecha no son compatibles:

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

O:

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

Si necesita el promedio y puede omitir el requisito de calcular la suma, puede calcular el promedio con una sola llamada de reducción:

// Assumes an array with only values that can be parsed to a Float
var reducer = function(cumulativeAverage, currentValue, currentIndex) {
  // 1. multiply average by currentIndex to find cumulative sum of previous elements
  // 2. add currentValue to get cumulative sum, including current element
  // 3. divide by total number of elements, including 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

Si alguien lo necesita, aquí hay un promedio recursivo.

En el contexto de la pregunta original, es posible que desee utilizar el promedio recursivo si permitió que el usuario inserte valores adicionales y, sin incurrir en el costo de visitar cada elemento nuevamente, desea "actualizar" el promedio existente.

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

Cómo:

esto funciona manteniendo el promedio actual y el recuento de elementos. Cuando se va a incluir un nuevo valor, incrementa el recuento en 1, escala el promedio existente en (count-1) / county agreganewValue / count al promedio.

Beneficios:

• no suma todos los elementos, lo que puede resultar en un gran número que no puede almacenarse en un flotante de 64 bits.
• puede "actualizar" un promedio existente si hay valores adicionales disponibles.
• puede realizar un promedio móvil sin conocer la longitud de la secuencia.

Desventajas:

• incurre en muchas más divisiones
• no infinito: limitado a Number.MAX_SAFE_INTEGER elementos a menos que emplee BigNumber

Promedio de itens de contenido HTML

Con jQuery o Javascript querySelectortiene acceso directo a datos formateados ... Ejemplo:

<p>Elements for an average: <span class="m">2</span>, <span class="m">4</span>,
   <span class="m">2</span>, <span class="m">3</span>.
</p>

Entonces, con jQuery tienes

var A = $('.m')
  .map(function(idx) { return  parseInt($(this).html()) })
  .get();
var AVG = A.reduce(function(a,b){return a+b}) / A5.length;

Vea otras 4 formas más (!) Para acceder a itens y promediarlo: http://jsfiddle.net/4fLWB/

var arr = [1,2,3,4,5]

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

avg (arr) ====== >>>> 3

Esto funciona con cadenas como números o números en la matriz.

    var scores =[90, 98, 89, 100, 100, 86, 94];
        var sum = 0;
        var avg = 0;
        for(var i = 0; i < scores.length;i++){
  //Taking sum of all the arraylist
            sum = sum + scores[i];   
                }
  //Taking average     
             avg = sum/scores.length;        
  //this is the function to round a decimal no    
             var round = avg.toFixed();
             console.log(round);

Recomendaría D3 en este caso. Es el más legible (y proporciona 2 tipos diferentes de promedios)

let d3 = require('d3');
let array = [1,2,3,4];
let sum = d3.sum(array); //10
let mean = d3.mean(array); //2.5
let median = d3.median(array);