Question

好的，所以我已经找到了解决问题的方法，但它很丑陋，而且我确信有更优雅的方法可以做到。

说我有两个数组（我知道长度相同），简单的对象，如下：

var aVals = [{a: 1}, {a: 2}, {a: 3}];

var bVals = [{b: 4}, {b: 5}, {b: 6}];

我想要做的是将这两个数组压缩在一起，可以说，得到的东西看起来像这样：

var allVals = [{a: 1, b: 4},{a: 2, b: 5},{a: 3, b: 6}];

当然，我可以这样做：

var uglySolution = [];

for(var i = 0; i < aVals.length; i++){
  var temp = [];
  temp.push(aVals[i]);
  temp.push(bVals[i]);
  uglySolution.push(Object.assign({}, ...temp)); 
}

console.log(uglySolution);

但必须有更好的方法！正确？

*奖金任务：如果我不能确定两个阵列的长度相同怎么办？

Answer 1

您可以使用Array.from功能。

检查最大长度。
检查两个阵列的特定索引处的对象。

＆＃13;

var aVals = [{a: 1}, {a: 2}, {a: 3}];
var bVals = [{b: 4}, {b: 5}, {b: 6}, {a: 4}];

var merge = Array.from({length: Math.max(aVals.length, bVals.length)}, (_, i) => {
  return Object.assign({}, bVals[i] || {}, aVals[i] || {});
});

console.log(merge)

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

Answer 2

如果你有相同长度的数组，那很简单：

＆＃13;

var aVals = [{a: 1}, {a: 2}, {a: 3}];
var bVals = [{b: 4}, {b: 5}, {b: 6}];
var result = aVals.map((el, i) => Object.assign({}, el, bVals[i]));

console.log(result);

＆＃13;

要使用不同的数组长度，我可以这样做：

＆＃13;

var aVals = [{a: 1}, {a: 2}];
var bVals = [{b: 4}, {b: 5}, {b: 6}];
var result = [];
var length = Math.max(aVals.length, bVals.length);

for (var i = 0; i < length; i++) {
  result.push(Object.assign({}, aVals[i] || {}, bVals[i] || {}));
}

console.log(result);

＆＃13;

Answer 3

你可以摆脱temp var和uglySolution var。

for (var i = 0; i < bVals.length; i++) {
    aVals.push(bVals.pop())
}
console.log(aVals);

这将它简化为一个正在使用的var并且只是一个小循环。

Answer 4

你可以像这样在for循环中找到一行：

var uglySolution = [];

for(var i = 0; i < aVals.length; i++){
  uglySolution.push(Object.assign({}, aVals[i], bVals[i]))
}

console.log(uglySolution);

假设两个阵列的大小相同。

如果它们的大小不同，请执行以下操作：

var uglySolution = [];
var longestLength =  aVals.length >  bVals.length ? aVals.length : bVals.length;

for(var i = 0; i < longestLength; i++){
  uglySolution.push(Object.assign({}, aVals[i] || {} , bVals[i] || {}))
}

console.log(uglySolution);

Answer 5

我认为这会好一点。

var aVals = [{a: 1}, {a: 2}, {a: 3}];

var bVals = [{b: 4}, {b: 5}, {b: 6}];

var result = aVals.map((val, index) => Object.assign(val, bVals[index]));

console.log(result);

Answer 6

我认为您的解决方案很好。它有效并且可读，所以我认为不需要“更好的解决方案”。但是，如果你正在寻找更短的东西，你肯定可以压缩你的代码。

这是使用数组解构和对象传播的一种方法。只需取较长的数组，并将其中的每个项目映射到该项目的组合，并将项目映射到另一个数组中相同的位置。

var aVals = [{a: 1}, {a: 2}, {a: 3}];
var bVals = [{b: 4}, {b: 5}, {b: 6}, {b: 7}];

// var allVals = [{a: 1, b: 4},{a: 2, b: 5},{a: 3, b: 6}];

function zipArrays(arr1, arr2) {
    // Swap if arr2 is longer, so that on the next line, arr1 is always longer
    if (arr2.length > arr1.length) [arr1, arr2] = [arr2, arr1];
    return arr1.map((o, i) => ({...o, ...arr2[i]}));
}

console.log(zipArrays(aVals, bVals))

Answer 7

您可以使用ES6并执行类似的操作。

＆＃13;

int GetNext(int curr) {
    int start = curr;

    for (curr++; curr != start; curr++) {
        if (curr >= NUM){
            curr = 0;
        }

        if (now[curr].actv == 1) {
            return curr;
        }
    }
    return -1;
}

＆＃13;

Answer 8

您可以使用数据收集所有数组，并使用适用于具有对象和长度的给定数组的任意计数的方法。

var merge = (r, a) => (a.forEach((o, i) => Object.assign(r[i] = r[i] || {}, o)), r)
    aVals = [{ a: 1 }, { a: 2 }, { a: 3 }],
    bVals = [{ b: 4 }, { b: 5 }, { b: 6 }],
    result = [aVals, bVals].reduce(merge, []);
    
console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 9

要实现预期的结果，请使用带有数组解析的forEach方法，它适用于任何数组长度

＆＃13;

routes.rb

＆＃13;

代码示例 - https://codepen.io/pen/?editors=1010

将对象数组合并为一个对象数组

9 个答案: