Sto riscontrando problemi nell'aggiungere tutti gli elementi di un array e nel fare la media. Come lo farei e lo implementerei con il codice che ho attualmente? Gli elementi dovrebbero essere definiti come li ho qui sotto.

<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 scorrere attraverso l'array, poiché i valori sono stringhe, devono prima essere convertiti in un numero intero. E la media è solo la somma dei valori divisa per il numero di valori.

Una soluzione che ritengo più 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);

Calcolo della media (media) utilizzando ridurre ed ES6:

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

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

generalmente la media usando una riduzione di una riga è come questa

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

in particolare alla domanda posta

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 versione efficiente è come

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

Comprendi l'array Javascript Riduci in 1 minuto http://www.airpair.com/javascript/javascript-array-reduce

come sottolineato da Gotofritz, Array.reduce ignora valori indefiniti. quindi ecco una soluzione:

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

Immaginiamo di avere un array di numeri interi come questo:

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

La media è ottenuta con la seguente formula

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

Dividiamo il valore corrente per il numero di valori e aggiungiamo il risultato precedente al valore restituito.

La firma del metodo di riduzione è

reduce(callback[,default_previous_value])

La funzione di riduzione della richiamata accetta i seguenti parametri:

• p : risultato del calcolo precedente
• c : valore corrente (dall'indice corrente)
• i : valore indice dell'elemento della matrice corrente
• a : La matrice ridotta corrente

Il parametro del secondo riduttore è il valore predefinito ... (Usato nel caso in cui l'array sia vuoto ).

Quindi il metodo di riduzione medio sarà:

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

Se preferisci, puoi creare una funzione separata

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

Quindi fai semplicemente riferimento alla firma del metodo di callback

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

Oppure aumenta direttamente il prototipo di array ..

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

È possibile dividere il valore ogni volta che viene chiamato il metodo di riduzione.

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

O ancora meglio , usando il precedentemente definito Array.protoype.sum ()

metodo, ottimizza il processo chiamando la divisione solo una volta :)

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

Quindi su qualsiasi oggetto Array dell'ambito:

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

NB: un array vuoto con ritorno di un desiderio NaN è più corretto di 0 dal mio punto di vista e può essere utile in casi d'uso specifici.

Puoi anche usare lodash , _.sum (array) e _.mean (array) nella parte Math (hai anche altre cose utili).

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

Non il più veloce, ma il più breve e in una riga utilizza map () & reduce ():

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

Un modo subdolo per farlo, anche se richiede l'uso di (il tanto odiato) 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/>");

Ho pensato di pubblicarlo come una di quelle opzioni "fuori dagli schemi". Non si sa mai, l'astuzia potrebbe concederti (o toglierti) un punto.

Uso questi metodi nella mia biblioteca personale:

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: per usarli, basta chiedere all'array la sua somma o media, come:

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

Nei browser predisposti per ES6 questo polyfill può essere utile.

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

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

È possibile condividere lo stesso metodo chiamata tra Math.sum, Math.avg e Math.max, come ad esempio

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

puoi usare Math.sum come

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

o se hai un array da riassumere, puoi usare

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

proprio come

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

Ecco una rapida aggiunta all'oggetto "Math" in javascript per aggiungere un comando "medio" ad esso !!

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

Quindi ho questa aggiunta all'oggetto "Math" per ottenere la somma!

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

Quindi tutto ciò che fai è

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

E dove ho inserito l'array segnaposto, basta passare la tua variabile (L'input se sono numeri può essere una stringa a causa della sua analisi di un numero!)

imposta il tuo contatore for loop su 0 .... stai ottenendo l'elemento 9 e poi hai finito come lo hai ora. Le altre risposte sono matematica di base. Utilizzare una variabile per memorizzare la somma (è necessario eseguire il cast delle stringhe in ints) e dividerla per la lunghezza dell'array.

Inizia definendo tutte le variabili che intendiamo utilizzare. Noterai che per l' numbersarray sto usando la notazione letterale []rispetto al metodo del costruttore array(). Inoltre, sto usando un metodo più breve per impostare più variabili su 0.

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

Quindi sto popolando il mio array di numeri vuoti con i valori da 0 a 11. Questo è per portarmi al punto di partenza originale. Nota come sto spingendo sull'array count++. Questo spinge il valore corrente di conteggio e quindi lo incrementa per la volta successiva.

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

Infine, sto eseguendo una funzione "per ciascuno" dei numeri nella matrice numerica. Questa funzione gestirà un numero alla volta, che sto identificando come "n" all'interno del corpo della funzione.

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

Alla fine, possiamo visualizzare sia il sumvalore che il avgvalore sulla nostra console per vedere il risultato:

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

Guardalo in azione online su http://jsbin.com/unukoj/3/edit

Sto solo basando la risposta di Abdennour TOUMI. ecco i motivi per cui:

1.) Sono d'accordo con Brad, non credo sia una buona idea estendere l'oggetto che non abbiamo creato.

2.) array.lengthè esattamente affidabile in javascript, preferisco Array.reduceallucinante a=[1,3];a[1000]=5;, ora a.lengthsarebbe tornato 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 ) ; 
};

Poi :

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

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

Sui browser sempreverdi è possibile utilizzare le funzioni freccia avg = [1,2,3].reduce((a,b) => (a+b);

Eseguendolo 100.000 volte, la differenza di tempo tra l'approccio for loop e la riduzione è trascurabile.

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

Una fodera media più corta:

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

Solo per calci:

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

Penso che possiamo fare come

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

Sto usando due volte parseFloat perché quando 1) aggiungi un numero (a) 9 + b ("1"), il risultato sarà "91" ma vogliamo aggiungere. così ho usato parseFloat

2) Quando si verifica l'aggiunta di (a) 9 + parseFloat ("1") anche se il risultato sarà "10", ma sarà in stringa che non vogliamo così di nuovo, ho usato parseFloat.

Spero di essere chiaro. Suggerimenti sono ben accetti

Ecco il mio modo da principiante di trovare semplicemente la media. Spero che questo aiuti qualcuno.

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

ecco la tua unica fodera:

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

Penso che questa possa essere una soluzione diretta per calcolare la media con un ciclo for e una funzione.

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

Sembra che ci sia un numero infinito di soluzioni per questo, ma l'ho trovato conciso ed 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 più coerentemente:

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

A seconda del browser, potrebbe essere necessario effettuare chiamate di funzione esplicite perché le funzioni freccia non sono supportate:

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

Se hai bisogno della media e puoi saltare il requisito del calcolo della somma, puoi calcolare la media con una sola chiamata di ridurre:

// 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 qualcuno ne ha mai bisogno - Ecco una media ricorsiva.

Nel contesto della domanda originale, potresti voler utilizzare la media ricorsiva se hai permesso all'utente di inserire valori aggiuntivi e, senza incorrere nel costo della visita di nuovo di ciascun elemento, volevi "aggiornare" la media esistente.

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

Come:

questo funziona mantenendo la media corrente e il conteggio degli elementi. Quando si deve includere un nuovo valore, si incrementa il conteggio di 1, si ridimensiona la media esistente di (count-1) / counte si aggiunge newValue / countalla media.

Benefici:

• non si sommano tutti gli elementi, il che può comportare un numero elevato che non può essere archiviato in un float a 64 bit.
• puoi "aggiornare" una media esistente se diventano disponibili valori aggiuntivi.
• puoi eseguire una media mobile senza conoscere la lunghezza della sequenza.

Svantaggi:

• comporta molte più divisioni
• non infinito: limitato a articoli Number.MAX_SAFE_INTEGER a meno che tu non lo impieghi BigNumber

Media dei contenuti HTML itens

Con jQuery o Javascript querySelectorhai accesso diretto ai dati formattati ... Esempio:

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

Quindi, con jQuery hai

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

Vedi altri 4 modi (!) Per accedere a itens e valutarlo in media: 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

Funziona con stringhe come numeri o numeri nell'array.

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

Consiglierei D3 in questo caso. È il più leggibile (e fornisce 2 diversi tipi di medie)

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