Ben bir dizinin tüm unsurları ekleme yanı sıra onları ortalama sorunları yaşıyorum. Bunu nasıl yapabilirim ve şu anda sahip olduğum kodla nasıl uygularım? Öğelerin aşağıda bende olduğu gibi tanımlanması gerekiyor.

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

Sadece diziyi yineleyin, değerleriniz dizeler olduğundan, önce bir tamsayıya dönüştürülmeleri gerekir. Ve ortalama sadece değerlerin toplamının değer sayısına bölünmesiyle elde edilir.

Daha zarif olduğunu düşündüğüm bir çözüm:

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

Kullanan ortalama (ortalama) hesaplanması azaltmak ve ES6:

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

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

genellikle tek katmanlı redüksiyon kullanarak ortalama böyle

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

özellikle sorulan soruya

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

verimli bir versiyon gibidir

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

1 Dakikada Javascript Dizi Azaltmasını Anlayın http://www.airpair.com/javascript/javascript-array-reduce

Gotofritz'in işaret ettiği gibi Array.reduce tanımlanmamış değerleri atlıyor. işte bir düzeltme:

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

Diyelim ki böyle bir tamsayı dizimiz var:

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

Ortalama aşağıdaki formülle elde edilir

A = (1 / n) Σxi (i = 1 ila n ile) ... Yani: x1 / n + x2 / n + ... + xn / n

Mevcut değeri değer sayısına böleriz ve önceki sonucu döndürülen değere ekleriz.

Küçültme yöntemi imzası:

reduce(callback[,default_previous_value])

Geri aramayı azaltma işlevi aşağıdaki parametreleri alır:

• p : Önceki hesaplamanın sonucu
• c : Geçerli değer (geçerli dizinden)
• i : Geçerli dizi öğesinin dizin değeri
• a : Akım azaltılmış Dizi

İkinci azaltma parametresi varsayılan değerdir ... (Dizinin boş olması durumunda kullanılır ).

Ortalama azaltma yöntemi şöyle olacaktır:

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

İsterseniz ayrı bir işlev oluşturabilirsiniz

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

Ve sonra sadece geri arama yöntemi imzasına bakın

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

Veya Array prototipini doğrudan artırın ..

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

İndirgeme yöntemi her çağrıldığında değeri bölmek mümkündür.

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

Ya da daha iyisi , daha önce tanımlanmış Array.protoype.sum () yöntemini kullanarak

yöntemi, benim bölünme sadece bir kez çağrı sürecini optimize :)

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

Sonra kapsamın herhangi bir Array nesnesinde:

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

Not: NaN isteği döndüren boş bir dizi benim görüşüme göre 0'dan daha doğrudur ve belirli kullanım durumlarında faydalı olabilir.

Ayrıca Math bölümünde lodash , _.sum (dizi) ve _.mean (dizi) kullanabilirsiniz (başka uygun şeyler de vardır).

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

En hızlı değil, en kısa ve tek satırda map () ve reduce () kullanılıyor:

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

(Çok nefret edilen) eval () kullanımını gerektirmesine rağmen bunu yapabileceğiniz sinsi bir yol.

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

Sadece bunu 'kutunun dışında' seçeneklerinden biri olarak göndereceğimi düşündüm. Asla bilemezsiniz, kurnazlık size bir nokta verebilir (ya da uzaklaştırabilir).

Kişisel kütüphanemde şu yöntemleri kullanıyorum:

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

DÜZENLEME: Bunları kullanmak için diziyi toplamını veya ortalamasını isteyin, örneğin:

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

In ES6 hazır tarayıcılar bu polyfill yararlı olabilir.

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

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

Aynı çağrı yöntemini arasında paylaşabilir Math.sum, Math.avg ve Math.maxgibi,

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

Math.sum'u

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

veya özetleyecek bir diziniz varsa,

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

tıpkı

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

İşte bir "ortalama" komut eklemek için javascript "Math" nesnesine hızlı bir ekleme !!

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

Sonra toplamı almak için "Matematik" nesnesine bu ek var!

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

O zaman tek yaptığınız

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

Ve ben yer tutucu dizi koymak sadece değişken geçmek (onlar sayı ise giriş bir sayı ayrıştırma nedeniyle bir dize olabilir!)

for döngüsü sayacınızı 0 olarak ayarlayın .... 9 elementini alıyorsunuz ve şimdi sahip olduğunuz gibi işiniz bitti. Diğer cevaplar temel matematiktir. Toplamınızı saklamak için bir değişken kullanın (dizeleri ints'e dökmeniz gerekir) ve dizi uzunluğuna bölün.

Kullanmayı planladığımız tüm değişkenleri tanımlayarak başlayın. numbersDizi []için yapıcı yönteminin aksine gerçek gösterimi kullandığımı not edeceksiniz array(). Ayrıca, birden çok değişkeni 0 olarak ayarlamak için daha kısa bir yöntem kullanıyorum.

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

Sonra boş sayılar dizimi 0'dan 11'e kadar olan değerlerle dolduruyorum. Bu beni orijinal başlangıç ​​noktasına götürmek. Diziye nasıl ittiğimi not edin count++. Bu sayımın geçerli değerini iter ve bir sonraki seferde değeri artırır.

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

Son olarak, numbers dizisindeki sayıların her biri için bir işlev gerçekleştiriyorum. Bu işlev, işlev gövdesinde "n" olarak tanımladığım bir kerede bir sayı işleyecektir.

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

Sonunda, sonucu görmek için hem sumdeğeri hem de değeri avgkonsolumuza gönderebiliriz:

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

Http://jsbin.com/unukoj/3/edit adresinden çevrimiçi olarak görün

Sadece Abdennour TOUMI'nin cevabı üzerine inşa ediyorum. İşte nedenleri:

1.) Brad ile hemfikirim, yaratmadığımız nesneyi uzatmanın iyi bir fikir olduğunu düşünmüyorum.

2.) array.lengthjavascript tam olarak güvenilir, Array.reduceçünkü beacuse tercih a=[1,3];a[1000]=5;, şimdi a.lengthdönecekti 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 ) ; 
};

Sonra :

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

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

Daima yeşil tarayıcılarda ok işlevlerini kullanabilirsiniz avg = [1,2,3].reduce((a,b) => (a+b);

100.000 kez çalıştırıldığında, for döngüsü yaklaşımı ve azaltma arasındaki zaman farkı göz ardı edilebilir.

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

Ortalama En Kısa Bir Astar:

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

Toplam En Kısa Bir Astar:

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

Sadece vuruşlar için:

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

Bence beğenebiliriz

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

Ben parseFloat iki kez kullanıyorum çünkü 1) (a) 9 + b ("1") numarası eklediğinizde sonuç "91" olacak ama ekleme istiyoruz. bu yüzden parseFloat kullandım

2) (a) 9 + parseFloat ("1") ilavesi sonuç "10" olsa da gerçekleşir, ancak yine istemediğimiz dize olacaktır.

Umarım netimdir. Öneriler bekliyoruz

İşte benim avg bulmanın çaylak yolu. Umarım bu birine yardımcı olur.

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

İşte tek astarınız:

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

Ben bir for döngüsü ve fonksiyonu ile ortalamayı hesaplamak için doğrudan bir çözüm olabileceğini düşünüyorum.

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

Bunun için sonsuz sayıda çözüm var gibi görünüyor ama bunu kısa ve zarif buldum.

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

Daha doğrusu:

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

Tarayıcınıza bağlı olarak, ok işlevleri desteklenmediği için açık işlev çağrıları yapmanız gerekebilir:

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

Veya:

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

Ortalamaya ihtiyacınız varsa ve toplamı hesaplama gereksinimini atlayabilirseniz, ortalamayı tek bir azaltma çağrısı ile hesaplayabilirsiniz:

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

Herkes buna ihtiyacı varsa - İşte özyinelemeli bir ortalama.

Orijinal soru bağlamında, kullanıcının ek değerler eklemesine izin verdiyseniz ve her bir öğeyi tekrar ziyaret etme maliyetine katlanmaksızın mevcut ortalamayı "güncellemek" istiyorsanız, yinelemeli ortalamayı kullanmak isteyebilirsiniz.

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

Nasıl:

bu, geçerli ortalama ve eleman sayısını koruyarak çalışır. Yeni bir değer ekleneceği zaman sayımı 1 arttırır, mevcut ortalamayı ölçeklendirir (count-1) / countvenewValue / count .

Yararları:

• 64 bit'lik bir floatta depolanamayan çok sayıda öğeye neden olabilecek tüm öğeleri toplamıyorsunuz.
• ek değerler mevcutsa mevcut bir ortalamayı "güncelleyebilirsiniz".
• dizi uzunluğunu bilmeden hareketli ortalama yapabilirsiniz.

Downsides:

• çok daha fazla bölüme giriyor
• sonsuz değil - Çalıştırmadığınız sürece Number.MAX_SAFE_INTEGER öğeyle sınırlıdır BigNumber

Ortalama HTML içeriği itens

JQuery veya Javascript querySelectorile biçimlendirilmiş verilere doğrudan erişiminiz olur ... Örnek:

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

Yani, jQuery ile

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

Itens'e erişmek ve ortalamasını almak için diğer 4 yolu (!) Görün: 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;
}

ort (arr) ====== >>>> 3

Bu, dizede sayı veya sayı olarak dizelerle çalışır.

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

Bu durumda D3'ü tavsiye ederim. En okunabiliridir (ve 2 farklı ortalama türü sağlar)

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