Question

在JavaScript中，给定n个数组作为此格式的输入：（n = 2）

array1:
[{x: 1, y: 5},{x: 2, y: 3},{x: 3, y: 6}]

array2:
[{x: 1, y: 2},{x: 2, y: 6},{x: 3, y: 2}]

如何轻松聚合Y值并获得此结果数组：

arrayOutput:
[{x: 1, y: 7},{x: 2, y: 9},{x: 3, y: 8}]

谢谢。

Answer 1

Benchmark Example

请注意，混合代码更快，然后是循环，后跟native / underscore。

function createOutput(arr1, arr2, arr3 /*, ... */) {
    return Array.prototype.reduce.call(arguments, function (prev, curr) {
        return prev.map(function(val, index) {
            return {
                x: val.x,
                y: val.y + curr[index].y
            }
        });
    });
}

假设数组已排序并包含x的所有值，顺序为1..n，没有间隙。

有点需要ES5。这可以换成_，它以跨浏览器的方式提供这种功能。

使用下划线

function createOutput() {
    return _.reduce(arguments, function (memo, arr) {
        return _.map(memo, function(val, index) {
            return { x: val.x, y: val.y + arr[index].y };
        });
    });
}

Answer 2

更新：关于x值及其在数组中的位置的附加注释使下面的内容无关紧要。

没有特别的技巧，你只需循环遍历数组并构建结果。它只不过是一个嵌套循环。如果您想在各种JavaScript引擎中实现最高效率，请避免不必要的函数调用。

东西沿着：

function sumYValues(arrays) {
    var outer, inner, array, entry, sum, result, x;

    // Create our result array with a copy of the first array
    result = [];
    if (arrays.length > 0) {
        array = arrays[0];
        for (inner = 0; inner < array.length; ++inner) {
            entry = array[inner];
            result[inner] = {x: entry.x, y: entry.y};
        }

        // Add in the remaining values
        for (outer = 1; outer < arrays.length; ++outer) {
            array = arrays[outer];
            // You might want an assert here verifying that result.length == array.length
            for (inner = 0; inner < array.length; ++inner) {
                entry = array[inner];
                // You might want an assert here verifying that result[inner].x == entry.x
                result[inner].y += entry.y;
            }
        }
    }

    return result;
}

这些循环从0（或1）到array.length - 1计算。您可以分析是否向后（array.length - 1到0（或1））更快，主要是“降至0”。我曾经认为这是因为当我是一个新面孔的年轻人时它在C中（与0的比较比与另一个变量的比较更快），但这种假设在JavaScript中可能有效，也可能没有效。

没有特别的捷径，你只需遍历数组，进行比较，然后建立你的结果。

如果x值在每个数组中都是唯一的，则可能更容易通过使用对象而不是数组并使用x值作为键来跟踪您的持续总和，然后完成后将其转换为数组。 E.g：

function sumYValues(arrays) {
    var outer, inner, ar, entry, sum, result, x;

    sum = {};
    for (outer = 0; outer < arrays.length; ++outer) {
        ar = arrays[outer];
        for (inner = 0; inner < arrays.length; ++inner) {
            entry = ar[inner];
            sum[entry.x] = (sum[entry.x] || 0) + entry.y;
        }
    }

    result = [];
    for (x in sum) {
        result.push({x: x, y: sum[x]});
    }

    return result;
}

上述内容主要是为了使用sum对象作为x =＆gt;的地图进行演示。 y值，尽管它确实实现了至少一些求和逻辑。

这一行可能需要一些解释：

            sum[entry.x] = (sum[entry.x] || 0) + entry.y;

如果sum没有该x值的条目，则sum[entry.x]将为undefined，这是一个“假”值。因此，我们使用curiously-powerful || operator从x 或 sum获取0的值，然后添加当前条目{{1}它存储结果。

聚合JavaScript数组的对象值？

2 个答案: