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

如果有人需要的话-这是递归平均。

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

/**
 * 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位浮点数中。 如果有其他值可用，您可以“更新”现有平均值。 您可以在不知道序列长度的情况下执行滚动平均。

缺点:

导致更多的分裂 不是无限的——仅限于数量。MAX_SAFE_INTEGER项，除非使用BigNumber

我觉得我们可以

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。

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

一种狡猾的方法可以做到这一点，尽管它确实需要使用(非常讨厌的)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/>");

我只是想把这个作为“盒子外”的选项之一。你永远不知道，狡猾可能会给你加分(或扣分)。

在支持es6的浏览器中，这个填充可能会有帮助。

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

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

你可以在Math.sum和Math.sum之间共享相同的调用方法。avg和Math。马克斯,如

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

你可以用数学。总和为

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

ES6

Const average = arr => arr。Reduce ((p, c) => p + c, 0) / arr.length; Const result = average([4,4,5,6,6]);/ / 5 console.log(结果);