Come calcolare la somma e la media degli elementi in un array?


177

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>

26
var elmt = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]sarebbe molto più bello.
James McLaughlin,

Risposte:


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


13
L'unico miglioramento che farei sarebbe sostituire for(var i = 0; i < elmt.length; i++;)confor(var i = 0, l = elmt.length; i < l; i++)
Dan D.

5
non essere quel ragazzo o essere fuori tema, ma è una buona pratica includere l'argomento radix in parseInt (). Con questo intendo sum += parseInt(elmt[i], 10);supporre che elmt [i] sia della base 10. link
Ryder Brooks

9
Fai attenzione alle divisioni per 0 (elmt.length might me 0)
caulitomaz,

2
@BramVanroy Racconto: No, non imposta 'l' ogni volta. Lunga storia: la soluzione di DanD è migliorare le prestazioni / la velocità, perché il controllo della lunghezza di un array ogni singola iterazione è più lento rispetto all'archiviazione effettiva della lunghezza in una variabile locale e al riferimento ad essa ogni iterazione.
CatalinBerta

9
@VitoGentile e DanD che pubblicizzano il codice per ottenere miglioramenti delle prestazioni che i moderni browser compilano comunque non dovrebbero essere le migliori pratiche.
nauti,

496

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

1
Questo non funzionerà su <= IE8, in quanto non supporta Array.prototype.reduce () Vedi di più su developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
aabele

14
con una media mobile cumulativa, puoi farlo tutto all'interno della funzione di riduzione (non è necessario per il sum/times.lengthpassaggio):var avg = times.reduce(function(p,c,i){return p+(c-p)/(i+1)},0);
zamnuts

6
@zamnuts Sono con te, penso che il commento di Thor84no sia totalmente fuori servizio - Sarei felice di essere licenziato da un posto che trova array.Riduce troppo complesso. Tuttavia non userei nemmeno il tuo codice, per il semplice fatto che ha una divisione e due aggiunte aggiuntive in ogni momento, che non sarà mai efficiente come una singola divisione alla fine
gotofritz

12
In ES2015 è un po 'più elegante. times.reduce((a,b) => (a+b)) / times.length;
Ray Foss,

12
@furf 5 anni dopo, sembra che in molti browser moderni, il più elegante "riduci ()" è più veloce (o altrettanto veloce). In Chrome 65 e la maggior parte di Firefox è meglio ridurre questo test.
Sir Robert,

116

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


3
Migliorato:Array.prototype.average = function () { var sum = 0, j = 0; for (var i = 0; i < this.length, isFinite(this[i]); i++) { sum += parseFloat(this[i]); ++j; } return j ? sum / j : 0; };
Gilad Peleg il

42
Per favore, non estendere oggetti non creati dal tuo codice.
Brad

1
UPDATE non funziona per: ["RER", "4", "3re", 5, new Object ()]. ​​Average (); restituisce 0 invece del previsto 4.5
Luckylooke

4
E questo si bloccherà in modo epico quando non c'è più lunghezza
Jimmy Kane il

2
@JimmyKane No, tornerà NaN.
bzeaman,

37

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

molto molto lento rispetto a una semplice aggiunta basata su loop con una somma somma jsben.ch/0xUus
PirateApp

Qui c'è una differenza del 25%. Non così male, penso.
Michael,

20

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

2
elements.length!=0?elements.length:1 può anche essere scritto in questo modo: elements.length || 1 che è più breve e più facile da leggere.
4rzael,

2
Ricorda che funziona solo con array senza spazi vuoti
gotofritz,

1
Suggerimento: aggiungi versioni non minime (in realtà solo piuttosto stampate) dei frammenti di codice in modo che le persone possano leggerle. Li modificherei in me stesso, ma non mi piace cambiare le risposte delle persone in quella misura.
Justin Morgan,

16

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.


13

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

6

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

1
forse più breve [7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0);ma con un comportamento diverso sull'array vuoto. Se si desidera che il risultato sia vuoto sull'array vuoto:[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")
Valen,

La mappa e la riduzione di Tobiq sono piuttosto standard da ES5 (standardizzata nel 2009)
Johann Echavarria,

for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / lengthMolto più chiaro, più breve e molto più veloce
Tobiq,

2
@Tobiq, il tuo codice è tutt'altro che chiaro. Questo tipo di loop è incomprensibile a prima vista.
Porkopek,

5

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.


+1 Una bella fodera efficiente! Se si tratta di Javascript nel browser lato client, l'unico eval()problema possibile che posso vedere è che devi essere sicuro che l'array contenga solo numeri (che ovviamente vale anche per tutte le altre risposte qui). Le voci non numeriche si arrestano in modo anomalo con un ReferenceErroro SyntaxError, except nested arrays of numbers which introduce , causando un totale numerico errato. E ovviamente in JS lato server, ad esempio node.js, eval()potrebbero naturalmente presentarsi problemi di sicurezza. Ma questo sembra perfetto per qualsiasi uso lato client ben strutturato.
user56reinstatemonica8

1
In realtà c'è forse un problema di prestazioni da includere in eval()questo modo - vedi la sezione prestazioni di nczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood
user56reinstatemonica8

5

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

Implementazione ordinata anche se avrei implementato la somma per usare un ciclo for invece di ridurre. Tuttavia, il codice è ancora molto pulito.
XDS

5

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

Invece di aggiungere metodi a Array.prototype, penso che l'aggiunta del tema Mathall'oggetto sia una scelta migliore: sono tutti "gestori di numeri".
Oboo Cheng,

3

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


1

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.


1

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


1

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

1
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

1

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


1
Devi saperne di più su console.time&console.timeEnd
Abdennour TOUMI,

@AbdennourTOUMI Grazie per il suggerimento, lo terrò a mente ... tuttavia non è standard e non è in linea con gli standard. developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd
Ray Foss

1
So che sto deviando le domande originali, ma che ne dici di usare performance.now () per le misurazioni delle prestazioni?
Deejbee,

@deejbee Offre precisione in virgola mobile ... ma è anche un po 'più prolisso e meno compatibile. Impostare marcatori con esso sarebbe utile nel codice del mondo reale
Ray Foss

1

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

0

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

0

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


0

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

0

ecco la tua unica fodera:

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

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

0

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

Stai facendo N divisioni nella funzione mappa. È meglio prima ridurre tutti i numeri a un valore totale e poi fare solo una divisione
Eugenio,

0

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

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

-1

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/


2
Sottotitoli perché l'OP ha chiesto di fare X e tu gli hai detto come fare Y poi X. Inoltre, l'idea di estrarre i dati dal DOM piuttosto che creare il DOM dai dati sembra qualcosa che probabilmente vorresti evitare comunque.
eremzeit,

Ciao @eremzeit, grazie attenzione. Uso il titolo in grassetto per dire "è un altro caso, con contenuti in HTML", per favore consideralo ... A proposito di pertinente, questo tipo di utilizzo (accesso diretto ai dati da HTML che l'utente vede) non è un gioco accademico ... Riguarda la "verità verificabile", ovvero in HTML (!), Non "nascosto agli umani" su javascript ... Non solo su Wikipedia, vedi casi tipici: 3,7 milioni di articoli scientifici al PMC , 6,6 MILIONI di documenti legislativi su LexML . Alcune persone non fanno solo design e giochi con js, fanno strumenti per l'audit.
Peter Krauss,

-1

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.


Qualche spiegazione della tua risposta è in ordine.
David Hoelzer,

Hai ragione: definito la somma come un numero in modo che funzioni ora. Alimenta la funzione un array e sputa la media dell'array.
Dan Chow,

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

1
Benvenuto in Stack Overflow. La tua risposta dovrebbe spiegare in dettaglio perché e come risponde alla domanda. Mentre i frammenti di codice sono incoraggiati, dovresti spiegare il codice in modo che i visitatori possano capirlo. C'è un modo per guida risposta qui: stackoverflow.com/help/how-to-answer
Crisma

-3

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

4
Accidenti, aggiungere l'intera D3 solo per
calcolare
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.