Question

我有一个数组数组，如下所示：var data = [[2, 2,3], [3, 9], [5, 6,7,8]]; （fiddle here）我需要能够根据每个内部数组的索引创建一个新数组。所以从上面的输出我正在寻找

1 - [2,3,5]
2 - [2,9,6]
3 - [3,7]
4 - [8]

帮助平均法：

Array.prototype.average = function () {
        var sum = this.sum();
        return sum / this.length;
    };

我有类似的东西：

var data = [[2, 2,3], [3, 9], [5, 6,7,8]];
    //Sconsole.log(data);

    Array.prototype.averageAll = function () {
        var avgArrays = [[]];
        var self = this;

        for (var i = 0; i < self.length; i++) {
            avgArrays[0].push(self[i][0]);
        }
        return avgArrays[0].average();
    };
    //3.333 to the console
    console.log(data.averageAll());

我在这个季节硬编码，因为如果我尝试使用avgArrays[i][i]，我会收到错误push is not defined。对于我的简单示例，该函数计算数组中每个数组的第0个位置的平均值。如果我有这样不同大小的数组，我怎么能一下子就这样做？

Answer 1

减少在这里可以派上用场 -

var data= [[2, 2, 3], [3, 9], [5, 6, 7, 8]];

data.Average= function(itm){
    return data.Sum(itm)/(itm.length);
}

data.Sum= function(itm){
    return itm.reduce(function(a, b){
        return a+b
    });
}
data.map(data.Average);

/*  returned value: (Array)
2.3333333333333335,6,6.5
*/

评论提醒我为IE8添加'shim'并降低其他浏览器获取地图并减少 -

(function(){
    var ap= Array.prototype; //IE8 & lower
    if(!ap.map){
        ap.map= function(fun, scope){
            var T= this, L= T.length, A= Array(L), i= 0;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in T){
                        A[i]= fun.call(scope, T[i], i, T);
                    }
                    ++i;
                }
                return A;
            }
        };
    }
    if(!ap.reduce){
        ap.reduce= function(fun, temp, scope){
            var T= this, i= 0, len= T.length, temp;
            if(typeof fun=== 'function'){
                if(temp== undefined) temp= T[i++];
                while(i<len){
                    if(i in T) temp= fun.call(scope, temp, T[i], i, T);
                    i++;
                }
            }
            return temp;
        }
    }
})();

Answer 2

我认为以下代码应该为您构建数组：

var data = [[2, 2,3], [3, 9], [5, 6,7,8]];
var max = 0;
for(var i = 0; i < data.length; i++) {
    max = data[i].length > max ? data[i].length : max
}

var result = [];
for(var i = 0; i < max; i++) {
    result[i] = [];
    for(var j = 0; j < data.length; j++) {
        if(i < data[j].length) {
            result[i].push(data[j][i]);
        }    
    }
}

在那之后，计算平均值是微不足道的：

var averages = [];
for(var i = 0; i < result.length; i++) {
    var array = result[i];

    var sum = 0;
    for(var j = 0; j < array.length; j++) {
        sum += array[j];
    }

    averages.push(sum / array.length);
}

Fiddle here

Answer 3

Array.prototype.sum = function () {
    var total = 0;
    for (var i = 0; i < this.length; i++) {
        total += this[i];
    }
    return total;
};
Array.prototype.average = function () {
    var sum = this.sum();
    return sum / this.length;
};
 var data = [[2, 2,3], [3, 9], [5, 6,7,8]];
//Sconsole.log(data);

Array.prototype.averageAll = function () {
    var avgArrays = [];
    var self = this;
    //in an array of arrays, val is an array
    var maxLen = 0;
    for(var i = 0; i < self.length; i++) {
        if(self[i].length > maxLen)            
        {
            maxLen = self[i].length;
        }
    }
    console.log('maxlen is ' + maxLen);
    for(var j = 0; j < maxLen; j++) {
        avgArrays.push([]);
        for(var k = 0; k < self.length; k++) {
            if(self[k][j]){
                   avgArrays[j].push(self[k][j]);
                }
        }
    }
    console.log(avgArrays);
    var result = []
    for (var x = 0; x < avgArrays.length; x++) {
        result.push(avgArrays[x].average());
    }
    return result;
};

console.log(data.averageAll());

Answer 4

因此，如果我理解正确，您需要一个由子阵列的平均值组成的新阵列？通过利用内置数组函数

，这是一种简单的方法

var data = [[2, 2,3], [3, 9], [5, 6,7,8]];

var averageAll = function(arr) {
  return arr.map(function(a) {
    return a.reduce(function(b,c) { return b+c; })/a.length;
  });
};

averageAll(data);
// -> [2.3333333333333335, 6, 6.5]

另外，根据经验，不要弄乱标准类型的原型，根据我的经验，它只会导致麻烦。

Answer 5

var data = [
    [2, 2, 3],
    [3, 9],
    [5, 6, 7, 8]
];

Array.prototype.averageAll = function() {
    var result = [],
        maxIdx = Math.max.apply(Math, this.map(function(arr) { return arr.length }));

    for (var i = 0; i < maxIdx; i++) {
        var sum = this.reduce(function(old, cur) {
            return old + (cur[i] || 0);
        }, 0);

        result.push(sum / this.length);
    }

    return result;
};

console.log(data.averageAll());
//[3.3333333333333335, 5.666666666666667, 3.3333333333333335, 2.6666666666666665]

fiddle

索引的平均锯齿状数组

5 个答案: