我在添加数组的所有元素以及平均它们时遇到问题。我该怎么做并用我目前的代码实现它？应该定义元素，如下所示。
<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>
答案 0 :(得分：430)
我认为更优雅的解决方案：
var sum, avg = 0;
// dividing by 0 will return Infinity
// arr must contain at least 1 element to use reduce
if (arr.length)
{
sum = arr.reduce(function(a, b) { return a + b; });
avg = sum / arr.length;
}
document.write("The sum is: " + sum + ". The average is: " + avg + "<br/>");
答案 1 :(得分：112)
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 );
只需遍历数组，因为您的值是字符串，所以必须先将它们转换为整数。而平均值只是值的总和除以值的数量。
答案 2 :(得分：79)
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 :(得分：20)
使用reduce和ES6计算平均值（均值）：
const average = list => list.reduce((prev, curr) => prev + curr) / list.length;
const list = [0, 10, 20, 30]
average(list) // 15
答案 4 :(得分：20)
一般使用单线降低的平均值就像这样
elements.reduce(function(sum, a,i,ar) { sum += a; return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);
专门询问问题
elements.reduce(function(sum, a,i,ar) { sum += parseFloat(a); return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);
高效版本就像
elements.reduce(function(sum, a) { return sum + a },0)/(elements.length||1);
在1分钟内理解Javascript数组减少 http://www.airpair.com/javascript/javascript-array-reduce
正如gotofritz所指出的那样，Array.reduce会跳过未定义的值。 所以这是一个修复：
(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])
答案 5 :(得分：14)
让我们假设我们有一个这样的整数数组：
var values = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
使用以下公式获得平均值
A =（1 / n）Σxi （i = 1到n） ......所以：x1 / n + x2 / n + ... + XN / N
我们将当前值除以值的数量，并将之前的结果添加到返回的值中。
reduce方法签名是
reduce(callback[,default_previous_value])
reduce回调函数采用以下参数：
第二个reduce的参数是默认值 ...（用于数组为空的情况下）。
所以平均reduce方法将是：
var avg = values.reduce(function(p,c,i,a){return p + (c/a.length)},0);
如果您愿意，可以创建单独的功能
function average(p,c,i,a){return p + (c/a.length)};
function sum(p,c){return p + c)};
然后简单地参考回调方法签名
var avg = values.reduce(average,0);
var sum= values.reduce(sum,0);
直接扩充Array原型..
Array.prototype.sum = Array.prototype.sum || function (){
return this.reduce(function(p,c){return p+c},0);
};
每次调用reduce方法时都可以对值进行除法。
Array.prototype.avg = Array.prototype.avg || function () {
return this.reduce(function(p,c,i,a){return p+(c/a.length)},0);
};
或更好，使用之前定义的 Array.protoype.sum（）
方法，优化我只调用一次除法的过程：）
Array.prototype.avg = Array.prototype.avg || function () {
return this.sum()/this.length;
};
然后在范围的任何Array对象上：
[2, 6].avg();// -> 4
[2, 6].sum();// -> 8
注意：在我的观点中，返回NaN愿望的空数组比0更正确，并且在特定用例中非常有用。
答案 6 :(得分：9)
您还可以在数学部分使用lodash，_。sum（数组）和_.mean（数组）（还有其他方便的工作人员）。
_.sum([4, 2, 8, 6]);
// => 20
_.mean([4, 2, 8, 6]);
// => 5
答案 7 :(得分：6)
不是最快的，但最短且在一行中使用map（）＆amp;减少（）：
var average = [7,14,21].map(function(x,i,arr){return x/arr.length}).reduce(function(a,b){return a + b})
答案 8 :(得分：5)
平均最短划线员人数：
let avg = [1,2,3].reduce((a,v,i)=>(a*i+v)/(i+1));
最短一线总和：
let sum = [1,2,3].reduce((a,b)=>a+b);
答案 9 :(得分：4)
我在我的个人图书馆中使用这些方法：
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);
}
编辑： 要使用它们，只需询问数组的总和或平均值，例如：
[1,2,3].sum() // = 6
[1,2,3].average() // = 2
答案 10 :(得分：4)
你可以做一个偷偷摸摸的方式，虽然它确实需要使用（非常讨厌的）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/>");
我以为我会发布这个“开箱即用”选项之一。你永远不会知道，狡猾可能会给你（或带走）一个点。
答案 11 :(得分：4)
在 ES6-ready 浏览器中，此polyfill可能会有所帮助。
Math.sum = (...a) => Array.prototype.reduce.call(a,(a,b) => a+b)
Math.avg = (...a) => this.sum(...a)/a.length;
您可以在Math.sum，Math.avg和Math.max之间共享相同的通话方式，例如
var maxOne = Math.max(1,2,3,4) // 4;
您可以将Math.sum用作
var sumNum = Math.sum(1,2,3,4) // 10
或者如果你有一个总结的数组，你可以使用
var sumNum = Math.sum.apply(null,[1,2,3,4]) // 10
就像
一样var maxOne = Math.max.apply(null,[1,2,3,4]) // 4
答案 12 :(得分：3)
以下是javascript中“Math”对象的快速添加，为其添加“普通”命令!!
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;
}
然后我在“Math”对象中添加了这个以获得总和！
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;
}
那么你所做的就是
alert(Math.sum([5,5,5])); //alerts “15”
alert(Math.average([10,0,5])); //alerts “5”
我把占位符数组放在你的变量中（输入如果它们是数字可以是一个字符串，因为它解析为一个数字！）
答案 13 :(得分：1)
将你的for循环计数器设置为0 ....你得到了元素9，然后就像现在一样完成了。其他答案是基础数学。使用变量来存储总和（需要将字符串转换为整数），然后除以数组长度。
答案 14 :(得分：1)
我正在建立在Abdennour TOUMI的答案上。以下是原因：
1。）我同意Brad的观点，我认为扩展我们没有创建的对象并不是一个好主意。
2。）array.length在javascript中完全可靠，我更喜欢Array.reduce beacuse a=[1,3];a[1000]=5;，现在a.length会返回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;
};
答案 15 :(得分：1)
如果有人需要-这是递归平均值。
在原始问题中，如果允许用户插入其他值，并且不希望再次访问每个元素而又想“更新”现有平均值，则可能要使用递归平均值。
/**
* 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
方法：
这通过保持当前平均值和元素计数来起作用。当要包含一个新值时，您可以将count递增1，将现有的平均值按(count-1) / count缩放，然后将newValue / count添加到平均值。
好处：
缺点：
BigNumber 答案 16 :(得分：1)
首先定义我们计划使用的所有变量。您会注意到，对于numbers数组，我使用[]的文字符号而不是构造函数方法array()。另外，我使用更短的方法将多个变量设置为0。
var numbers = [], count = sum = avg = 0;
接下来，我将使用值0到11填充空数字数组。这是为了让我到达原始起点。请注意我是如何推进阵列count++的。这会推动计数的当前值，然后将其递增以供下次使用。
while ( count < 12 )
numbers.push( count++ );
最后，我正在为数字数组中的每个数字执行一个函数。此函数将一次处理一个数字，我在函数体中识别为“n”。
numbers.forEach(function(n){
sum += n;
avg = sum / numbers.length;
});
最后，我们可以将sum值和avg值输出到控制台以查看结果：
// Sum: 66, Avg: 5.5
console.log( 'Sum: ' + sum + ', Avg: ' + avg );
答案 17 :(得分：1)
在常绿浏览器上，您可以使用箭头功能
avg = [1,2,3].reduce((a,b) => (a+b);
运行100,000次，for循环方法和reduce之间的时差可以忽略不计。
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.
*/
答案 18 :(得分：0)
阅读其他选择后，我将尝试为未来的观众制作一个更简单的版本，详细说明现有代码而不是创建更优雅的代码。首先，您将数字声明为字符串。除了 .parseInt 我们还可以这样做：
const numberConverter = elmt.map(Number);
那么 map 的作用是“返回原始数组的副本”。但我将其值转换为数字。然后我们可以使用 reduce 方法（它也可以更简单，但我正在编写易于阅读的版本，我也有 2 个平均方法）reduce 方法的作用是它有一个累加器，如果你添加值，它会变得越来越大它，因为它遍历数组并向其添加（在本例中）currentValue。：
var i;
const 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';
console.log(elmt);
const numberConverter = elmt.map(Number);
const sum = numberConverter.reduce((accumulator, currentValue) => {
return accumulator + currentValue;
}, 0);
const average = numberConverter.reduce(
(accumulator, currentvalue, index, numArray) => {
return accumulator + currentvalue / numArray.length;
},
0
);
const average2 =
numberConverter.reduce(
(accumulator, currentValue) => accumulator + currentValue,
0
) / numberConverter.length;
for (i = 9; i < 10; i++) {
console.log(
`The sum of all the elements is: ${sum}. <br> The average of all the elements is: ${average2}`
);}
答案 19 :(得分：0)
如果您需要平均值，并且可以跳过计算总和的要求，则可以通过一次调用reduce来计算平均值：
// 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
答案 20 :(得分：0)
似乎有无穷无尽的解决方案，但我发现它简洁而优雅。
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
或更明确地说：
const numbers = [1,2,3,4];
const average = numbers.map(x => x/numbers.length).reduce((adder, value) => (adder + value));
console.log(average); // 2.5
根据您的浏览器，您可能需要执行显式函数调用，因为不支持箭头函数：
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
或者：
const average1 = numbers
.map(function (x) {
return x/count;
})
.reduce(function (adder, value) {
return adder + value;
});
console.log(average1);
答案 21 :(得分：0)
我发现 Mansilla 的 answer 可以很好地使用扩展，以确保我正在对浮点数求和而不是使用 parseFloat() 进行字符串的串联：
let sum = ourarray.reduce((a, b) => parseFloat(a) + parseFloat(b), 0);
let avg = (sum / ourarray.length) || 0;
console.log(sum); // print out sum
console.log(avg); // print out avg
答案 22 :(得分：0)
我认为这可能是用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);
答案 23 :(得分：0)
这是你的一个班轮：
var average = arr.reduce((sum,item,index,arr)=>index !== arr.length-1?sum+item:sum+item/arr.length,0)
答案 24 :(得分：0)
这是我简单地找到平均值的新手方式。希望这有助于某人。
function numAvg(num){
var total = 0;
for(var i = 0;i < num.length; i++) {
total+=num[i];
}
return total/num.length;
}
答案 25 :(得分：0)
我认为我们可以这样做
var k=elmt.reduce(function(a,b){return parseFloat(a+parseFloat(b));})
var avg=k/elmt.length;
console.log(avg);
我使用parseFloat两次因为 什么时候 1）你添加（a）9 + b（＆＃34; 1＆＃34;）数字然后结果将是＆＃34; 91＆＃34;但我们想要补充。所以我使用了parseFloat
2）当添加（a）9 + parseFloat（＆＃34; 1＆＃34;）时，结果将是＆＃34; 10＆＃34;但它会在我们不想要的字符串中再次使用parseFloat。
我希望我很清楚。欢迎提出建议
答案 26 :(得分：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 ) ;
};
然后：
[ 1 , 2 , 3].avg() ; //-> OUT : 2
[{age:25},{age:26},{age:27}].avg(function(e){return e.age}); // OUT : 26
答案 27 :(得分：0)
只是为了踢：
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)));
答案 28 :(得分：-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）======＆gt;＆gt;＆gt;＆gt; 3
这适用于字符串作为数组中的数字或数字。
答案 29 :(得分：-1)
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);
答案 30 :(得分：-1)
使用jQuery或Javascript querySelector，您可以直接访问格式化数据......示例：
<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>
所以，使用jQuery你有
var A = $('.m')
.map(function(idx) { return parseInt($(this).html()) })
.get();
var AVG = A.reduce(function(a,b){return a+b}) / A5.length;
查看其他更多4种方式（！）来访问itens并对其进行平均：http://jsfiddle.net/4fLWB/
答案 31 :(得分：-2)
我有10个元素（如示例中所示），所以我做了：
( elmt[0] + elmt[1] + elmt[2] + elmt[3] + elmt[4] +
elmt[5] + elmt[6] + elmt[7] + elmt[8] + elmt[9] ) / 10
答案 32 :(得分：-2)
在这种情况下我会推荐D3。它是最具可读性的（并提供2种不同的平均值）
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);