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

一般来说，平均使用一行程序减少是这样的

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指出的数组。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])

我只是基于Abdennour TOUMI的回答。原因如下:

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

2)数组。长度在javascript中是完全可靠的，我更喜欢数组。因为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; 
};

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

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

接下来，我用0到11的值填充空数字数组。这是为了回到最初的起点。注意我是如何推入数组count++的。这将推动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 );

在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

怎样去:

这是通过维持当前的平均值和元素计数来工作的。当要包含一个新值时，将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。

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