Comment calculer la somme et la moyenne des éléments d'un tableau?


177

J'ai des problèmes pour ajouter tous les éléments d'un tableau et pour les calculer en moyenne. Comment pourrais-je faire cela et l'implémenter avec le code que j'ai actuellement? Les éléments sont censés être définis comme je l'ai ci-dessous.

<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]serait tellement plus agréable.
James McLaughlin

Réponses:


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

Effectuez simplement une itération dans le tableau, puisque vos valeurs sont des chaînes, elles doivent d'abord être converties en entier. Et la moyenne n'est que la somme des valeurs divisée par le nombre de valeurs.


13
La seule amélioration que je ferais serait de remplacer for(var i = 0; i < elmt.length; i++;)parfor(var i = 0, l = elmt.length; i < l; i++)
Dan D.

5
ne pas être ce gars-là ou être hors sujet, mais c'est une bonne pratique d'inclure l'argument radix dans parseInt (). J'entends par là en sum += parseInt(elmt[i], 10);supposant que elmt [i] est du lien de
Ryder Brooks

9
Attention aux divisions par 0 (elmt.length might me 0)
caulitomaz

2
@BramVanroy Petite histoire: Non, il ne met pas «l» à chaque fois. Longue histoire: la solution de DanD est d'améliorer les performances / la vitesse, car vérifier la longueur d'un tableau à chaque itération est plus lent que de stocker réellement la longueur dans une variable locale et de la référencer à chaque itération.
CatalinBerta

9
@VitoGentile et DanD uglifier le code pour des gains de performances que les navigateurs modernes compilent de toute façon ne devrait pas être une meilleure pratique.
nauti

496

Une solution que je considère plus élégante:

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
Cela ne fonctionnera pas sur <= IE8, car il ne prend pas en charge Array.prototype.reduce () Pour en savoir plus, consultez developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
aabele

14
avec une moyenne mobile cumulative, vous pouvez tout faire dans la fonction de réduction (pas besoin de l' sum/times.lengthétape):var avg = times.reduce(function(p,c,i){return p+(c-p)/(i+1)},0);
zamnuts

6
@zamnuts Je suis avec vous, je pense que Thor84no commentaire est totalement hors de propos - je serais heureux d'être viré d'un endroit qui trouve array.reduce trop complexe. Cependant, je n'utiliserais pas non plus votre code, pour le simple fait qu'il comporte une division et deux ajouts supplémentaires à chaque étape, ce qui ne sera jamais aussi efficace qu'une seule division à la fin
gotofritz

12
Dans ES2015, c'est un peu plus élégant. times.reduce((a,b) => (a+b)) / times.length;
Ray Foss

12
@furf 5 ans plus tard, on dirait que dans de nombreux navigateurs modernes, le plus élégant "reduction ()" est plus rapide (ou aussi rapide). Dans Chrome 65 et la plupart des firefox, réduire est meilleur sur ce 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
Amélioré: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

42
Veuillez ne pas étendre les objets qui ne sont pas créés par votre code.
Brad

1
UPDATE ne fonctionne pas pour: ["RER", "4", "3re", 5, new Object ()]. ​​Average (); renvoie 0 au lieu de 4,5 attendu
Luckylooke

4
Et cela plantera épiquement quand il n'y aura pas de longueur
Jimmy Kane

2
@JimmyKane Non, il reviendra NaN.
bzeaman

37

Calcul de la moyenne (moyenne) à l'aide de réduire et ES6:

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

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

très très lent comparé à un simple ajout basé sur une boucle for avec une variable de somme jsben.ch/0xUus
PirateApp

Ici, c'est une différence de 25%. Pas si mal, je pense.
Michael

20

généralement moyen en utilisant une seule ligne réduire est comme ça

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

spécifiquement à la question posée

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

une version efficace est comme

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

Comprendre Javascript Array Réduire en 1 minute http://www.airpair.com/javascript/javascript-array-reduce

comme gotofritz l'a souligné, Array.reduce ignore les valeurs non définies. alors voici une 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])

2
elements.length!=0?elements.length:1 peut également être écrit comme ceci: elements.length || 1 qui est plus court et plus facile à lire.
4rzael

2
Gardez à l'esprit que cela ne fonctionne que pour les tableaux sans espaces vides
gotofritz

1
Suggestion: ajoutez des versions non réduites (en fait juste assez imprimées) de vos extraits de code afin que les gens puissent les lire. Je les éditerais moi-même, mais je n'aime pas changer les réponses des gens à ce point.
Justin Morgan

16

Imaginons que nous ayons un tableau d'entiers comme celui-ci:

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

La moyenne est obtenue avec la formule suivante

A = (1 / n) Σxi (avec i = 1 à n) ... Donc: x1 / n + x2 / n + ... + xn / n

Nous divisons la valeur actuelle par le nombre de valeurs et ajoutons le résultat précédent à la valeur renvoyée.

La signature de la méthode de réduction est

reduce(callback[,default_previous_value])

La fonction de rappel de réduction prend les paramètres suivants:

  • p : résultat du calcul précédent
  • c : valeur actuelle (à partir de l'index actuel)
  • i : valeur d'index de l'élément de tableau actuel
  • a : Le réseau réduit actuel

Le deuxième paramètre de réduction est la valeur par défaut ... (Utilisé si le tableau est vide ).

Ainsi, la méthode de réduction moyenne sera:

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

Si vous préférez, vous pouvez créer une fonction distincte

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

Et puis référez-vous simplement à la signature de la méthode de rappel

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

Ou Augmentez directement le prototype Array.

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

Il est possible de diviser la valeur chaque fois que la méthode de réduction est appelée.

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

Ou encore mieux , en utilisant le Array.protoype.sum () précédemment défini

méthode, optimisez le processus en n'appelant la division qu'une seule fois :)

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

Puis sur n'importe quel objet Array de la portée:

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

NB: un tableau vide avec retour a NaN wish est plus correct que 0 à mon avis et peut être utile dans des cas d'utilisation spécifiques.


13

Vous pouvez également utiliser lodash , _.sum (tableau) et _.mean (tableau) dans la partie Math (également avoir d'autres choses pratiques).

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

6

Pas le plus rapide, mais le plus court et en une seule ligne utilise map () & reduction ():

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

1
peut-être plus court [7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0);mais avec un comportement différent sur un tableau vide. Si vous voulez que le résultat soit vide sur un tableau vide:[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")
Valen

@Tobiq map & Reduce sont assez standard depuis ES5 (standardisé en 2009)
Johann Echavarria

for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / lengthBeaucoup plus clair, plus court et beaucoup plus rapide
Tobiq

2
@Tobiq, votre code est tout sauf clair. Ce type de boucle est inintelligible à première vue.
Porkopek

5

Une façon sournoise de le faire bien qu'elle nécessite l'utilisation de (le plus détesté) 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/>");

Je pensais juste que je publierais cela comme l'une de ces options «hors des sentiers battus». Vous ne savez jamais, la ruse pourrait vous accorder (ou vous enlever) un point.


+1 Belle doublure efficace! S'il s'agit de Javascript dans le navigateur côté client, le seul eval()problème possible que je peux voir est que vous devez vous assurer que le tableau ne contient que des nombres (ce qui est bien sûr également vrai pour toutes les autres réponses ici). Les entrées non numériques se bloquent avec un ReferenceErrorou SyntaxError, except nested arrays of numbers which introduce , `provoquant un total numérique incorrect. Et bien sûr, dans JS côté serveur, par exemple node.js, cela eval()pourrait naturellement introduire des problèmes de sécurité. Mais cela semble parfait pour toutes les utilisations côté client bien structurées.
user56reinstatemonica8

1
En fait, il y a peut-être un problème de performance à inclure eval()comme ça - voir la section sur les performances de nczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood
user56reinstatemonica8

5

J'utilise ces méthodes dans ma bibliothèque personnelle:

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: Pour les utiliser, demandez simplement au tableau sa somme ou sa moyenne, comme:

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

Une implémentation soignée bien que j'aurais implémenté sum pour utiliser une boucle for au lieu de réduire. Encore très bien codé.
XDS

5

Dans les navigateurs compatibles ES6, ce polyfill peut être utile.

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

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

Vous pouvez partager la même méthode d'appel entre Math.sum, Math.avg et Math.max, comme

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

vous pouvez utiliser Math.sum comme

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

ou si vous avez un tableau à résumer, vous pouvez utiliser

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

juste comme

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

Au lieu d'ajouter des méthodes à Array.prototype, je pense que l'ajout d'un thème à un Mathobjet est un meilleur choix - ce sont tous des "gestionnaires de nombres".
Oboo Cheng

3

Voici un ajout rapide à l'objet «Math» en javascript pour y ajouter une commande «moyenne» !!

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

Ensuite, j'ai cet ajout à l'objet "Math" pour obtenir la somme!

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

Alors tout ce que tu fais c'est

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

Et où je mets le tableau d'espace réservé, passez simplement votre variable (L'entrée s'il s'agit de nombres peut être une chaîne à cause de son analyse en un nombre!)


1

réglez votre compteur de boucle for à 0 ... vous obtenez l'élément 9 et vous avez terminé comme vous l'avez maintenant. Les autres réponses sont des mathématiques de base. Utilisez une variable pour stocker votre somme (besoin de convertir les chaînes en entiers) et divisez par la longueur de votre tableau.


1

Commencez par définir toutes les variables que nous prévoyons d'utiliser. Vous noterez que pour le numberstableau, j'utilise la notation littérale de []par opposition à la méthode du constructeur array(). De plus, j'utilise une méthode plus courte pour définir plusieurs variables sur 0.

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

Ensuite, je remplis mon tableau de nombres vides avec les valeurs 0 à 11. C'est pour m'amener à votre point de départ d'origine. Notez comment je pousse sur le tableau count++. Cela pousse la valeur actuelle de count, puis l'incrémente pour la prochaine fois.

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

Enfin, j'exécute une fonction "pour chacun" des nombres dans le tableau des nombres. Cette fonction gérera un nombre à la fois, que j'identifie comme "n" dans le corps de la fonction.

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

En fin de compte, nous pouvons afficher à la fois la sumvaleur et la avgvaleur sur notre console afin de voir le résultat:

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

Voyez-le en action en ligne à http://jsbin.com/unukoj/3/edit


1

Je ne fais que construire sur la réponse d'Abdennour TOUMI. voici les raisons pour lesquelles:

1.) Je suis d'accord avec Brad, je ne pense pas que ce soit une bonne idée d'étendre un objet que nous n'avons pas créé.

2.) array.lengthest exactement fiable en javascript, je préfère Array.reducebeacuse a=[1,3];a[1000]=5;, maintenant a.lengthreviendrait 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 ) ; 
};

Ensuite :

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

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

1

Sur les navigateurs Evergreen, vous pouvez utiliser les fonctions fléchées avg = [1,2,3].reduce((a,b) => (a+b);

En l'exécutant 100 000 fois, le décalage horaire entre l'approche de la boucle for et la réduction est négligeable.

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
Vous devez en savoir plus sur console.time&console.timeEnd
Abdennour TOUMI

@AbdennourTOUMI Merci pour le conseil, je vais le garder à l'esprit ... mais ce n'est pas standard et pas sur la voie des normes. developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd
Ray Foss

1
Je sais que je me détourne des questions d'origine, mais que diriez-vous d'utiliser performance.now () pour mesurer les performances?
deejbee

@deejbee Cela offre une précision en virgule flottante ... mais c'est aussi un peu plus verbeux et moins compatible. Définir des marqueurs avec lui serait utile dans le code du monde réel
Ray Foss

1

Une doublure moyenne la plus courte:

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

Somme la plus courte d'une doublure:

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

0

Juste pour l'adrénaline:

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

Je pense que nous pouvons faire comme

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

J'utilise parseFloat deux fois parce que lorsque 1) vous ajoutez (a) 9 + b ("1") nombre, le résultat sera "91" mais nous voulons une addition. donc j'ai utilisé parseFloat

2) Lorsque l'ajout de (a) 9 + parseFloat ("1") se produit bien que le résultat soit "10" mais ce sera dans une chaîne que nous ne voulons pas alors j'ai utilisé parseFloat.

J'espère que je suis clair. Les suggestions sont les bienvenues


0

Voici ma façon novice de trouver simplement la moyenne. J'espère que cela aide quelqu'un.

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

0

voici votre seule doublure:

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

0

Je pense que cela peut être une solution directe pour calculer la moyenne avec une boucle et une fonction for.

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

Il semble y avoir un nombre infini de solutions pour cela, mais j'ai trouvé cela concis et élégant.

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 plus simplement:

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

En fonction de votre navigateur, vous devrez peut-être effectuer des appels de fonction explicites car les fonctions fléchées ne sont pas prises en charge:

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

Vous créez N divisions dans la fonction de carte. Il est préférable de réduire d'abord tous les nombres à une valeur totale, puis de ne faire qu'une seule division
Eugenio

0

Si vous avez besoin de la moyenne et pouvez ignorer l'exigence de calcul de la somme, vous pouvez calculer la moyenne avec un seul appel de réduire:

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

Si quelqu'un en a besoin - Voici une moyenne récursive.

Dans le contexte de la question d'origine, vous souhaiterez peut-être utiliser la moyenne récursive si vous avez autorisé l'utilisateur à insérer des valeurs supplémentaires et, sans encourir le coût de la visite à nouveau de chaque élément, souhaitez «mettre à jour» la moyenne existante.

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

Comment:

cela fonctionne en conservant la moyenne actuelle et le nombre d'éléments. Lorsqu'une nouvelle valeur doit être incluse, vous incrémentez le nombre de 1, mettez à l'échelle la moyenne existante de (count-1) / countet ajouteznewValue / count à la moyenne.

Avantages:

  • vous ne faites pas la somme de tous les éléments, ce qui peut entraîner un grand nombre qui ne peut pas être stocké dans un flottant 64 bits.
  • vous pouvez «mettre à jour» une moyenne existante si des valeurs supplémentaires deviennent disponibles.
  • vous pouvez effectuer une moyenne mobile sans connaître la longueur de la séquence.

Inconvénients:

  • entraîne beaucoup plus de divisions
  • pas infini - limité à Number.MAX_SAFE_INTEGER articles sauf si vous employez BigNumber

-1

Moyenne du contenu HTML itens

Avec jQuery ou Javascript, querySelectorvous avez un accès direct aux données formatées ... Exemple:

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

Donc, avec jQuery vous avez

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

Voir d'autres méthodes 4 (!) Pour y accéder et faire la moyenne: http://jsfiddle.net/4fLWB/


2
Downvote parce que l'OP a demandé à faire X et que vous lui avez dit comment faire Y puis X. De plus, l'idée d'extraire des données du DOM plutôt que de créer le DOM à partir de données semble être quelque chose que vous voudriez probablement éviter de toute façon.
eremzeit

Salut @eremzeit, merci attention. J'utilise un titre en gras pour dire "c'est un autre cas, avec des contenus en HTML", veuillez le considérer ... A propos de pertinence, ce type d'utilisation (accès direct aux données HTML que l'utilisateur voit) n'est pas un jeu académique ... Il s'agit de la «vérité auditable», c'est-à-dire en HTML (!), Pas «cachée aux humains» chez javascript ... Pas seulement sur Wikipédia, voir des cas typiques: 3,7 millions d'articles scientifiques à PMC , 6,6 MILLIONS de documents législatifs à LexML . Certaines personnes ne font pas que du design et des jeux avec js, font des outils d'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

Cela fonctionne avec des chaînes sous forme de nombres ou de nombres dans le tableau.


Une explication de votre réponse s'impose.
David Hoelzer

Vous avez raison: la somme définie comme un nombre pour que cela fonctionne maintenant. Nourrissez la fonction d'un tableau et il crache la moyenne du tableau.
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
Bienvenue dans Stack Overflow. Votre réponse doit expliquer en détail pourquoi et comment elle répond à la question. Bien que les extraits de code soient encouragés, vous devez expliquer le code afin que les visiteurs puissent le comprendre. Il y a un guide de réponse ici: stackoverflow.com/help/how-to-answer
ChrisM

-3

Je recommanderais D3 dans ce cas. C'est le plus lisible (et fournit 2 types de moyennes différents)

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
Gosh ajouter tout le D3 juste pour calculer une moyenne est ridicule
gotofritz
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.