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

我在个人图书馆中使用了以下方法：

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

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”

在哪里放置占位符数组，只需传入您的变量即可（如果输入是数字，则可以是字符串，因为它会解析为数字！）

有一个狡猾的方法可以做到这一点，尽管它需要使用(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/>");

我想提供一个“出奇制胜”的选项。你永远不知道，这种狡猾的方法可能会给你（或夺走）一分。

我发现Mansilla的答案可以很好地处理我的需求，通过使用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

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

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

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

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

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

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

在线查看演示，请访问http://jsbin.com/unukoj/3/edit

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

如何实现：

通过保持当前平均值和元素计数来实现。当要包含新值时，将计数增加1，通过 (count-1) / count 缩放现有平均值，并将 newValue / count 添加到平均值中。

优点：

• 不需要对所有元素求和，这可能会导致无法存储在64位浮点数中的大数字。
• 如果有额外的值可用，可以“更新”现有的平均值。
• 可以执行滚动平均而不知道序列长度。

缺点：

• 会产生更多的除法运算。
• 不是无限的 - 除非使用BigNumber，否则仅限于 Number.MAX_SAFE_INTEGER 项。

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

仅供娱乐

let avg = [81, 77, -88, 195, 6.8].reduce((a,e,i) => (a*i+e)/(i+1));

console.log(avg)