Estou tendo problemas para adicionar todos os elementos de uma matriz e fazer a média deles. Como eu faria isso e o implementaria com o código que tenho atualmente? Os elementos devem ser definidos como eu abaixo.

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

Basta percorrer a matriz, já que seus valores são cadeias de caracteres, eles devem ser convertidos em um número inteiro primeiro. E a média é apenas a soma dos valores divididos pelo número de valores.

Uma solução que considero mais 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 da média (média) usando reduzir e ES6:

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

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

geralmente média usando one-liner reduzir é assim

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

especificamente para a pergunta

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

uma versão eficiente é como

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

Compreender a matriz de Javascript Reduzir em 1 minuto http://www.airpair.com/javascript/javascript-array-reduce

como gotofritz apontou, parece que Array.reduce ignora valores indefinidos. então aqui está uma correção:

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

Vamos imaginar que temos uma matriz de números inteiros como este:

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

A média é obtida com a seguinte fórmula

A = (1 / n) Σxi (com i = 1 para n) ... Então: x1 / n + x2 / n + ... + xn / n

Dividimos o valor atual pelo número de valores e adicionamos o resultado anterior ao valor retornado.

A assinatura do método de redução é

reduce(callback[,default_previous_value])

A função de redução de retorno de chamada utiliza os seguintes parâmetros:

• p : Resultado do cálculo anterior
• c : valor atual (do índice atual)
• i : Valor do índice do elemento da matriz atual
• a : A matriz reduzida atual

O segundo parâmetro de redução é o valor padrão ... (Usado no caso de a matriz estar vazia ).

Portanto, o método de redução média será:

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

Se preferir, você pode criar uma função separada

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

E, em seguida, basta consultar a assinatura do método de retorno de chamada

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

Ou aumente o protótipo da matriz diretamente.

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

É possível dividir o valor cada vez que o método de redução é chamado.

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

Ou melhor ainda , usando o Array.protoype.sum () definido anteriormente

método, otimizar o processo chamando a divisão apenas uma vez :)

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

Então, em qualquer objeto Array do escopo:

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

Nota: um array vazio com retorno de um desejo NaN é mais correto que 0 no meu ponto de vista e pode ser útil em casos de uso específicos.

Você também pode usar lodash , _.sum (array) e _.mean (array) na parte Math (também possui outros itens convenientes).

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

Não é o mais rápido, mas o mais curto e em uma linha está usando map () e reduza ():

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

Uma maneira sorrateira de fazê-lo, embora exija o uso de (o tão 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/>");

Só pensei em postar isso como uma daquelas opções 'fora da caixa'. Você nunca sabe, a astúcia pode lhe conceder (ou tirar) um ponto.

Eu uso esses métodos na minha biblioteca pessoal:

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

EDIT: Para usá-los, basta pedir ao array sua soma ou média, como:

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

Em navegadores prontos para ES6, esse polyfill pode ser útil.

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

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

Você pode compartilhar o mesmo método de chamada entre Math.sum, Math.avg e Math.max, como

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

você pode usar Math.sum como

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

ou se você tiver uma matriz para resumir, poderá usar

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

Assim como

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

Aqui está uma rápida adição ao objeto "Math" em javascript para adicionar um comando "médio" a ele !!

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

Então eu tenho essa adição ao objeto "Math" para obter a soma!

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

Então tudo que você faz é

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

E onde eu coloquei a matriz de espaço reservado, basta passar sua variável (a entrada, se forem números, pode ser uma string por causa da análise de um número!)

defina seu contador de loop for como 0 .... você está obtendo o elemento 9 e, em seguida, está pronto como o possui agora. As outras respostas são matemática básica. Use uma variável para armazenar sua soma (é necessário converter as strings em ints) e divida pelo comprimento da matriz.

Comece definindo todas as variáveis ​​que planejamos usar. Você notará que, para a numbersmatriz, estou usando a notação literal []em oposição ao método construtor array(). Além disso, estou usando um método mais curto para definir várias variáveis ​​como 0.

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

Em seguida, estou preenchendo minha matriz de números vazios com os valores de 0 a 11. Isso é para me levar ao seu ponto de partida original. Observe como estou pressionando a matriz count++. Isso pressiona o valor atual de count e o incrementa para a próxima vez.

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

Por fim, estou executando uma função "para cada" dos números na matriz de números. Essa função manipulará um número de cada vez, que eu estou identificando como "n" no corpo da função.

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

No final, podemos gerar o sumvalor e o avgvalor para nosso console para ver o resultado:

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

Veja em ação online em http://jsbin.com/unukoj/3/edit

Estou apenas aproveitando a resposta de Abdennour TOUMI. Aqui estão as razões do porquê:

1.) Concordo com Brad, não acho que seja uma boa ideia estender um objeto que não criamos.

2.) array.lengthé exatamente confiável em javascript, prefiro Array.reduceporque a=[1,3];a[1000]=5;, agora a.lengthretornaria 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 ) ; 
};

Então :

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

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

Em navegadores sempre verdes, você pode usar as funções de seta avg = [1,2,3].reduce((a,b) => (a+b);

Ao executá-lo 100.000 vezes, a diferença de tempo entre a abordagem do loop for e a redução é 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.
 */

Um forro mais curto médio:

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

Apenas por diversão:

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

Acho que podemos fazer como

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

Estou usando parseFloat duas vezes porque quando 1) você adiciona (a) 9 + b ("1"), o resultado será "91", mas queremos adição. então eu usei parseFloat

2) Quando a adição de (a) 9 + parseFloat ("1") acontece, o resultado será "10", mas será na string que não queremos, então usei parseFloat.

Espero estar claro. Sugestões são bem-vindas

Aqui está o meu jeito novato de simplesmente encontrar a média. Espero que isso ajude alguém.

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

aqui está o seu forro:

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

Eu acho que isso pode ser uma solução direta para calcular a média com um loop e função.

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 haver um número infinito de soluções para isso, mas eu achei isso conciso e 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

Ou de forma mais consistente:

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

Dependendo do seu navegador, pode ser necessário fazer chamadas de função explícitas porque as funções de seta não são suportadas:

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

Ou:

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

Se você precisar da média e puder ignorar o requisito de calcular a soma, poderá calcular a média com uma única chamada de redução:

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

Se alguém precisar - aqui está uma média recursiva.

No contexto da pergunta original, convém usar a média recursiva se você permitir que o usuário insira valores adicionais e, sem incorrer no custo de visitar cada elemento novamente, deseje "atualizar" a média 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

Quão:

isso funciona mantendo a média atual e a contagem de elementos. Quando um novo valor deve ser incluído, você incrementa a contagem em 1, escala a média existente em (count-1) / counte adicionanewValue / count à média.

Benefícios:

• você não soma todos os elementos, o que pode resultar em um grande número que não pode ser armazenado em um flutuador de 64 bits.
• você pode "atualizar" uma média existente se valores adicionais estiverem disponíveis.
• você pode executar uma média móvel sem saber o tamanho da sequência.

Desvantagens:

• incorre muito mais divisões
• não infinito - limitado a itens Number.MAX_SAFE_INTEGER, a menos que você use BigNumber

Média de itens de conteúdo HTML

Com jQuery ou Javascript, querySelectorvocê tem acesso direto a dados formatados ... Exemplo:

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

Então, com o jQuery você tem

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

Veja outras 4 maneiras (!) De acessar itens e calcule a média: 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;
}

média (arr) ====== >>>> 3

Isso funciona com cadeias de caracteres como números ou números na 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);

Eu recomendaria o D3 neste caso. É o mais legível (e fornece 2 tipos diferentes de médias)

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