似乎有无数的解决方案，但我发现这个是简洁和优雅的。

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

Or:

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

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

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

我觉得我们可以

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。

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

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

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

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

你也可以使用lodash， _.sum(数组)和_.mean(数组)在数学部分(也有其他方便的东西)。

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

这里是一个快速添加到“数学”对象在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”

我把占位符数组只是传递在你的变量(输入如果他们是数字可以是一个字符串，因为它解析到一个数字!)