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>

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.

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

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

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

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

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.

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

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

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.

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

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

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

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.

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

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

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

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

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

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

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

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

voici votre seule doublure:

var average = arr.reduce((sum,item,index,arr)=>index !== arr.length-1?sum+item:sum+item/arr.length,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);

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

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

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

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/

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.

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

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