如何计算数组中元素的总和和平均值？

Posted 2023-02-15

【中文标题】如何计算数组中元素的总和和平均值？

【英文标题】：How to compute the sum and average of elements in an array?

【发布时间】：2012-05-08 17:58:54

【问题描述】：

我在添加数组的所有元素以及平均它们时遇到问题。我将如何做到这一点并使用我目前拥有的代码来实现它？元素应该按照我在下面定义的那样定义。

<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 elmt = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 会好很多。

【参考方案1】：

我认为更优雅的解决方案：

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

【讨论】：

这不适用于 developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…查看更多信息

使用累积移动平均线，您可以在 reduce 函数内完成所有操作（无需 sum/times.length 步骤）：var avg = times.reduce(function(p,c,i)return p+(c-p)/(i+1),0);

@zamnuts 我支持你，我认为 Thor84no 的评论完全不正常 - 我很高兴从一个发现 array.reduce 过于复杂的地方被解雇。但是我也不会使用你的代码，因为它在每一步都有一个除法和两个额外的添加，这永远不会像最后的单个除法那样有效

在 ES2015 中它更加优雅。 times.reduce((a,b) => (a+b)) / times.length;

@furf 5 年后，看起来在许多现代浏览器中，更优雅的“reduce()”更快（或一样快）。在 Chrome 65 和大多数 Firefox 中，reduce 在该测试中表现更好。

【参考方案2】：

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

只需遍历数组，因为您的值是字符串，所以必须先将它们转换为整数。而平均值只是值的总和除以值的数量。

【讨论】：

我要做的唯一改进是将for(var i = 0; i < elmt.length; i++;)替换为for(var i = 0, l = elmt.length; i < l; i++)

不要成为那个人或离题，但在 parseInt() 中包含 radix 参数是一个好习惯。我的意思是sum += parseInt(elmt[i], 10); 假设 elmt[i] 以 10 为底。link

注意除以 0（elmt.length 可能是 0）

@BramVanroy 短篇小说：不，它不会每次都设置“l”。长话短说：DanD 的解决方案是提高性能/速度，因为每次迭代检查数组的长度比将长度实际存储在局部变量中并在每次迭代中引用它要慢。

@VitoGentile 和 DanD 丑化代码以获得现代浏览器编译掉的性能提升不应该是最佳实践。

【参考方案3】：

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

【讨论】：

改进：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; ;

请不要扩展不是由您的代码创建的对象。

更新不适用于：["RER","4","3re",5,new Object()].average();返回 0 而不是预期的 4.5

当没有长度时这会严重崩溃

@JimmyKane 不，它会返回NaN。

【参考方案4】：

使用reduce 和 ES6 计算平均值：

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

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

【讨论】：

与一个简单的基于循环的加法相比非常非常慢

这里有 25% 的差异。我认为还不错。

【参考方案5】：

一般平均使用单线reduce是这样的

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

【讨论】：

elements.length!=0?elements.length:1 也可以这样写：elements.length || 1 更短，更易于阅读。

请记住，这只适用于没有空白的数组

建议：添加未缩小（实际上只是打印精美）的代码 sn-ps 版本，以便人们可以阅读它们。我会自己编辑它们，但我不喜欢在这种程度上改变人们的答案。

【参考方案6】：

假设我们有一个这样的整数数组：

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 回调函数接受以下参数：

p

: 结果 之前的计算

c

：当前值（来自当前索引）

i

: 当前数组元素的索引值

a

: 当前缩小的数组

第二个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 更正确，并且在特定用例中很有用。

【参考方案7】：

平均最短一条线：

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

Sum Shortest One Liner：

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

【讨论】：

如果您将返回值切换为a+(v-a)/(i+1)，您将保持相同数量的字符并使其在数值上更加稳定，尤其是相对于除以array.length的所有答案而言

【参考方案8】：

您还可以在数学部分使用lodash、_.sum(array) 和 _.mean(array)（还有其他方便的东西）。

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

【讨论】：

意思是不是一个函数？

【参考方案9】：

不是最快的，但最短的一行是使用 map() 和 reduce()：

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

【讨论】：

可能更短 [7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0); 但在空数组上的行为不同。如果您确实希望空数组上的结果为空：[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")

@Tobiq map & reduce 是自 ES5 以来的标准（2009 年标准化）

for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / length 更清晰、更短、更快速

@Tobiq，您的代码一点也不清晰。这种类型的循环乍一看难以理解。

【参考方案10】：

我在我的个人库中使用这些方法：

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

【讨论】：

整洁的实现虽然我会实现 sum 以使用 for 循环而不是 reduce。不过，代码仍然非常干净。

【参考方案11】：

在支持 ES6 的浏览器中，这个 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

【讨论】：

比起给Array.prototype添加方法，我认为给Math对象添加主题是更好的选择——它们都是“数字处理器”。

【参考方案12】：

一种偷偷摸摸的方式你可以做到，尽管它确实需要使用（非常讨厌的）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/>");

只是想我会将其发布为“框外”选项之一。你永远不会知道，狡猾可能会让你（或拿走）一分。

【讨论】：

+1 不错的高效单线！如果它是客户端的浏览器内 Javascript，我能看到的唯一可能的 eval() 问题是您需要确保数组仅包含数字（这当然也适用于此处的所有其他答案）。非数字条目因ReferenceError 或SyntaxError, except nested arrays of numbers which introduce 而崩溃，`导致数字总数不正确。当然在服务器端 JS 中，例如node.js，那么自然eval() 可能会引入安全问题。但这看起来非常适合任何结构良好的客户端使用。

实际上像这样包含eval() 可能存在性能问题 - 请参阅nczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood 的性能部分

【参考方案13】：

这是在 javascript 中快速添加“数学”对象以添加“平均”命令！

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

我把占位符数组放在哪里只是传入你的变量（如果它们是数字，输入可以是一个字符串，因为它解析为一个数字！）

【参考方案14】：

将您的 for 循环计数器设置为 0...。您将获得元素 9，然后您就完成了现在的操作。其他答案是基本数学。使用变量来存储总和（需要将字符串转换为整数），然后除以数组长度。

【参考方案15】：

首先定义我们计划使用的所有变量。您会注意到，对于numbers 数组，我使用的是[] 的文字符号，而不是构造方法array()。此外，我使用更短的方法将多个变量设置为 0。

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

接下来，我将使用 0 到 11 的值填充我的空数字数组。这是为了让我到达您最初的起点。请注意我是如何推送到数组count++ 上的。这会推动 count 的当前值，然后在下一次将其递增。

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

最后，我正在为 numbers 数组中的每个数字执行一个函数。此函数将一次处理一个数字，我在函数体中将其标识为“n”。

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

最后，我们可以将sum 值和avg 值都输出到我们的控制台以查看结果：

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

通过http://jsbin.com/unukoj/3/edit在线查看实际操作

【参考方案16】：

我只是建立在 Abdennour TOUMI 的回答之上。原因如下：

1.) 我同意 Brad 的观点，我认为扩展我们没有创建的对象不是一个好主意。

2.) array.length 在 javascript 中完全可靠，我更喜欢 Array.reduce 因为 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; 
;

【参考方案17】：

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

【参考方案18】：

在常青浏览器上，您可以使用箭头功能 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.
 */

【讨论】：

你需要了解更多关于console.time & console.timeEnd

@AbdennourTOUMI 感谢您的提示，我会记住的……但是它是非标准的，不在标准轨道上。 developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd

我知道我正在偏离原来的问题，但是使用 performance.now() 进行性能测量怎么样？

@deejbee 这确实提供了浮点精度......但它也有点冗长且不兼容。用它设置标记在现实世界的代码中很有用

【参考方案19】：

如果您需要平均值并且可以跳过计算总和的要求，您可以通过一次调用 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】：

如果有人需要它 - 这是一个递归平均值。

在原始问题的上下文中，如果您允许用户插入额外的值，并且在不产生再次访问每个元素的成本的情况下想要“更新”现有平均值，您可能希望使用递归平均值。

/**
 * 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 添加到平均值。

好处：

您没有对所有元素求和，这可能会导致无法存储在 64 位浮点数中的大量数字。 如果有其他值可用，您可以“更新”现有平均值。 您可以在不知道序列长度的情况下执行滚动平均。

缺点：

招致更多部门 不是无限的 - 仅限于 Number.MAX_SAFE_INTEGER 项，除非您使用 BigNumber

【参考方案21】：

在阅读了其他选择之后，我将尝试为未来的观众制作一个更简单的版本，详细说明现有的代码，而不是创建一个更优雅的代码。首先，您将数字声明为字符串。除了 .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`
  );

【参考方案22】：

我发现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

【参考方案23】：

只是为了好玩：

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

【参考方案24】：

我认为我们可以这样做

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("1") 数字然后结果将是 "91" 但我们想要添加。所以我使用了 parseFloat

2)当添加 (a)9+parseFloat("1") 虽然结果将是 "10" 但它会在我们不想要的字符串中，所以我再次使用了 parseFloat。

我希望我很清楚。欢迎提出建议

【参考方案25】：

这是我简单地找到平均值的新手方法。希望这对某人有所帮助。

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

【参考方案26】：

这是你的一个班轮：

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

【参考方案27】：

我认为这可能是使用 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);

【参考方案28】：

似乎有无数种解决方案，但我发现它简洁而优雅。

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

【讨论】：

您在地图功能中进行了 N 个划分。最好先将所有数字归一化，然后只进行一次除法

【参考方案29】：

html 内容的平均值

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

【讨论】：

投反对票，因为 OP 要求做 X，而您告诉他如何做 Y 然后 X。此外，从 DOM 中提取数据而不是从数据中创建 DOM 的想法似乎是您的想法d 可能还是想避免。

嗨@eremzeit，谢谢关注。我用粗体标题说“它是另一种情况，内容为HTML”，请考虑一下......关于相关，这种使用（直接访问用户看到的HTML数据）不是学术游戏......它是关于“可审计的真相”，即 HTML（！），而不是 javascript 中的“对人类隐藏”......不仅在***，请参阅典型案例：3.7 million scientific articles at PMC，6.6 MILLION of legislative documents at LexML。有些人不仅用js做设计和游戏，还做审计工具。

【参考方案30】：

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;

平均（arr）======>>>> 3

这适用于字符串作为数组中的数字或数字。

【讨论】：

您的答案的一些解释是有序的。

你是对的：将 sum 定义为一个数字，以便现在可以使用。为函数提供一个数组，它会输出数组的平均值。