Saya mengalami masalah dalam menambahkan semua elemen array serta rata-rata keluar. Bagaimana saya melakukan ini dan menerapkannya dengan kode yang saya miliki saat ini? Elemen seharusnya didefinisikan seperti yang saya miliki di bawah ini.

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

Hanya beralih melalui array, karena nilai Anda adalah string, mereka harus dikonversi ke integer terlebih dahulu. Dan rata-rata hanyalah jumlah nilai yang dibagi dengan jumlah nilai.

Solusi yang saya anggap lebih elegan:

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

Menghitung rata-rata (rata-rata) menggunakan pengurangan dan ES6:

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

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

umumnya rata-rata menggunakan pengurangan satu-liner adalah seperti ini

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

khusus untuk pertanyaan yang diajukan

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

versi yang efisien seperti

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

Memahami Mengurangi Array Javascript dalam 1 Menit http://www.airpair.com/javascript/javascript-array-reduce

seperti yang ditunjukkan oleh Gotofritz tampaknya Array.reduce melewatkan nilai yang tidak ditentukan. jadi di sini adalah perbaikannya:

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

Bayangkan kita memiliki array bilangan bulat seperti ini:

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

Rata-rata diperoleh dengan rumus berikut

A = (1 / n) Σxi (dengan i = 1 ke n) ... Jadi: x1 / n + x2 / n + ... ... xn / n

Kami membagi nilai saat ini dengan jumlah nilai dan menambahkan hasil sebelumnya ke nilai yang dikembalikan.

Tanda tangan metode pengurangan adalah

reduce(callback[,default_previous_value])

Fungsi mengurangi panggilan balik mengambil parameter berikut:

• p : Hasil perhitungan sebelumnya
• c : Nilai saat ini (dari indeks saat ini)
• i : Nilai indeks elemen array saat ini
• a : Array berkurang saat ini

Parameter reduksi kedua adalah nilai default ... (Digunakan jika array kosong ).

Jadi metode pengurangan rata-rata adalah:

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

Jika mau, Anda dapat membuat fungsi terpisah

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

Dan kemudian cukup merujuk ke tanda tangan metode panggilan balik

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

Atau menambah prototipe Array secara langsung ..

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

Dimungkinkan untuk membagi nilai setiap kali metode pengurangan dipanggil ..

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

Atau bahkan lebih baik , menggunakan Array.protoype.sum () yang didefinisikan sebelumnya

metode, mengoptimalkan proses saya memanggil divisi hanya sekali :)

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

Kemudian pada objek array apa pun dari ruang lingkup:

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

NB: array kosong dengan mengembalikan harapan NaN lebih benar daripada 0 dalam sudut pandang saya dan dapat berguna dalam kasus penggunaan tertentu.

Anda juga dapat menggunakan lodash , _.sum (array) dan _.mean (array) di bagian Math (juga memiliki hal-hal praktis lainnya).

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

Bukan yang tercepat, tetapi yang terpendek dan dalam satu baris menggunakan map () & kurangi ():

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

Salah satu cara licik Anda bisa melakukannya walaupun memang membutuhkan penggunaan (yang paling dibenci) 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/>");

Hanya berpikir saya akan memposting ini sebagai salah satu opsi 'di luar kotak'. Anda tidak pernah tahu, kecerdikan mungkin memberi Anda (atau menghilangkan) satu poin.

Saya menggunakan metode ini di perpustakaan pribadi saya:

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: Untuk menggunakannya, cukup tanyakan jumlah atau rata-rata array, seperti:

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

Di browser ES6-ready , polyfill ini mungkin bisa membantu.

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

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

Anda dapat berbagi metode panggilan yang sama antara Math.sum, Math.avg dan Math.max, seperti

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

Anda dapat menggunakan Math.sum sebagai

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

atau jika Anda memiliki array untuk diringkas, Anda dapat menggunakan

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

seperti

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

Berikut ini adalah tambahan cepat ke objek "Math" di javascript untuk menambahkan perintah "rata-rata" ke dalamnya !!

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

Maka saya memiliki tambahan ini ke objek "Matematika" untuk mendapatkan jumlah!

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

Jadi semua yang Anda lakukan adalah

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

Dan di mana saya meletakkan array placeholder hanya lewat di variabel Anda (Input jika mereka angka bisa menjadi string karena itu parsing ke angka!)

atur loop counter Anda ke 0 .... Anda mendapatkan elemen 9 dan kemudian selesai seperti sekarang. Jawaban lainnya adalah matematika dasar. Gunakan variabel untuk menyimpan jumlah Anda (perlu memberikan string ke ints), dan bagi dengan panjang array Anda.

Mulailah dengan mendefinisikan semua variabel yang kami rencanakan untuk digunakan. Anda akan mencatat bahwa untuk numbersarray, saya menggunakan notasi literal yang []bertentangan dengan metode konstruktor array(). Selain itu, saya menggunakan metode yang lebih pendek untuk mengatur beberapa variabel menjadi 0.

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

Selanjutnya saya mengisi array angka kosong saya dengan nilai 0 hingga 11. Ini untuk membawa saya ke titik awal semula. Perhatikan bagaimana saya mendorong ke array count++. Ini mendorong nilai hitungan saat ini, dan kemudian meningkatkannya untuk waktu berikutnya.

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

Terakhir, saya melakukan fungsi "untuk masing-masing" angka dalam array angka. Fungsi ini akan menangani satu angka pada satu waktu, yang saya identifikasi sebagai "n" di dalam tubuh fungsi.

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

Pada akhirnya, kita bisa menampilkan sumnilai, dan avgnilai ke konsol kita untuk melihat hasilnya:

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

Lihat beraksi online di http://jsbin.com/unukoj/3/edit

Saya hanya membangun jawaban Abdennour TOUMI. berikut alasannya:

1.) Saya setuju dengan Brad, saya pikir itu bukan ide yang bagus untuk memperluas objek yang tidak kita buat.

2.) array.lengthtepat dapat diandalkan dalam javascript, saya lebih suka Array.reducekarena a=[1,3];a[1000]=5;sekarang a.lengthakan kembali 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 ) ; 
};

Kemudian :

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

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

Pada browser evergreen Anda dapat menggunakan fungsi panah avg = [1,2,3].reduce((a,b) => (a+b);

Menjalankannya 100.000 kali, perbedaan waktu antara pendekatan for loop dan reduksi diabaikan.

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

Average One Liner Terpendek:

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

Jumlah Terpendek Satu Liner:

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

Hanya untuk iseng:

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

Saya pikir kita bisa melakukannya

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

Saya menggunakan parseFloat dua kali karena ketika 1) Anda menambahkan (a) angka 9 + b ("1") maka hasilnya adalah "91" tetapi kami ingin penambahan. jadi saya menggunakan parseFloat

2) Ketika penambahan (a) 9 + parseFloat ("1") terjadi meskipun hasilnya akan "10" tetapi itu akan menjadi string yang tidak kita inginkan jadi saya menggunakan parseFloat lagi.

Saya harap saya jelas. Saran diterima

Inilah cara pemula saya hanya menemukan rata-rata. Semoga ini bisa membantu seseorang.

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

inilah satu liner Anda:

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

Saya pikir ini mungkin solusi langsung untuk menghitung rata-rata dengan for for loop dan function.

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

Tampaknya ada banyak solusi untuk ini, tetapi saya menemukan ini ringkas dan elegan.

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

Atau lebih tepatnya:

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

Bergantung pada browser Anda, Anda mungkin perlu melakukan panggilan fungsi eksplisit karena fungsi panah tidak didukung:

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

Atau:

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

Jika Anda membutuhkan rata-rata dan dapat melewati persyaratan penghitungan jumlah, Anda dapat menghitung rata-rata dengan satu panggilan pengurangan:

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

Jika ada yang membutuhkannya - Ini adalah rata-rata rekursif.

Dalam konteks pertanyaan awal, Anda mungkin ingin menggunakan rata-rata rekursif jika Anda mengizinkan pengguna untuk memasukkan nilai-nilai tambahan dan, tanpa menimbulkan biaya mengunjungi setiap elemen lagi, ingin "memperbarui" rata-rata yang ada.

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

Bagaimana:

ini berfungsi dengan mempertahankan rata-rata dan jumlah elemen saat ini. Ketika nilai baru akan dimasukkan, Anda menambah hitungan dengan 1, skala rata-rata yang ada oleh (count-1) / count, dan tambahkannewValue / count rata-rata.

Manfaat:

• Anda tidak menjumlahkan semua elemen, yang dapat menghasilkan sejumlah besar yang tidak dapat disimpan dalam float 64-bit.
• Anda dapat "memperbarui" rata-rata yang ada jika nilai tambahan tersedia.
• Anda dapat melakukan rolling average tanpa mengetahui panjang urutannya.

Kerugian:

• menimbulkan lebih banyak divisi
• tidak terbatas - terbatas pada Number.MAX_SAFE_INTEGER item kecuali Anda mempekerjakan BigNumber

Rata-rata konten HTML itens

Dengan jQuery atau Javascript, querySelectorAnda memiliki akses langsung ke data yang diformat ... Contoh:

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

Jadi, dengan jQuery yang Anda miliki

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

Lihat 4 cara (!) Lainnya untuk mengakses itens dan rata-rata: 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;
}

rata-rata (arr) ====== >>>> 3

Ini berfungsi dengan string sebagai angka atau angka dalam 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);

Saya akan merekomendasikan D3 dalam hal ini. Ini adalah yang paling mudah dibaca (dan menyediakan 2 jenis rata-rata)

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