例子:

var array1 = [ {'key':1, 'property1': 'x'}, {'key':2, 'property1': 'y'} ]
var array2 = [ {'key':2, 'property2': 'a'}, {'key':1, 'property2': 'b'} ]

我想要 merge(array1, array2) 给我:

[
    {'key':1, 'property1': 'x', 'property2' : 'b'},
    {'key':2, 'property1': 'y', 'property2' : 'a'}
]

有没有简单的方法来做到这一点？

编辑:几个人回答时并没有太仔细地看我的问题，请注意我想匹配每个数组中的相似对象并将它们的属性组合到我的最终数组中。键是唯一的，每个数组中最多只有一个对象具有特定键。

最佳答案

我写了一个快速 不太快速的解决方案。您可能要考虑的一个问题是，第二个数组中某个对象的属性是否应该覆盖与其进行比较的第二个对象中的相同属性(如果存在)。

解决方案1

这个解决方案很复杂O(n²) .解决方案 2 更快；此解决方案仅适用于那些不想成为 Sanic the Hedgehog 的人快。

JavaScript

var mergeByKey = function (arr1, arr2, key) {
// key is the key that the function merges based on
    arr1.forEach(function (d, i) {
        var prop = d[key];
        // since keys are unique, compare based on this key's value
        arr2.forEach(function (f) {
            if (prop == f[key]) {    // if true, the objects share keys
                for (var x in f) {   // loop through each key in the 2nd object
                    if (!(x in d))   // if the key is not in the 1st object
                        arr1[i][x] = f[x];    // add it to the first object
                // this is the part you might want to change for matching properties
                // which object overrides the other?
                }
            }
        })
    })
    return arr1;
}

测试用例

var arr = [ {'key':1, 'property1': 'x'},
            {'key':2, 'property1': 'y'} ],
    arr2= [ {'key':2, 'property2': 'a'},
            {'key':1, 'property2': 'b'} ];

console.log(mergeByKey(arr, arr2, "key"));

结果

/* returns:
    Object
    key: 1
    property1: "x"
    property2: "b"
    __proto__: Object
and 
    Object
    key: 2
    property1: "y"
    property2: "a"
    __proto__: Object
*/

fiddle

解决方案2

作为Vivin Paliath在下面的评论中指出，我的第一个解决方案是 O(n²)复杂性(阅读:坏)。他的回答非常好，提供了一个复杂度为O(m + n)的解决方案。 , 其中m是第一个数组的大小，n第二个阵列。换句话说，复杂性 O(2n) .

但是，他的解决方案并未解决对象中的对象。为了解决这个问题，我使用了递归——阅读:魔鬼，就像O(n²)一样。 .

JavaScript

var mergeByKey = function (arr1, arr2, key) {
    var holder = [],
        storedKeys = {},
        i = 0; j = 0; l1 = arr1.length, l2 = arr2.length;

    var merge = function (obj, ref) {
        for (var x in obj) {
            if (!(x in ref || x instanceof Object)) {
                ref[x] = obj[x];
            } else {
                merge(obj[x], ref[x]);
            }
        }
        storedKeys[obj.key] = ref;
    }
    for (; i < l1; i++) {
        merge(arr1[i], storedKeys[arr1[i].key] || {});
    }
    for (; j < l2; j++) {
        merge(arr2[j], storedKeys[arr2[j].key] || {});
    }

    delete storedKeys[undefined];

    for (var obj in storedKeys)
        holder.push(storedKeys[obj]);

    return holder;
}

测试用例

var arr1 = [
    {
        "key" : 1,
        "prop1" : "x",
        "test" : {
            "one": 1,
            "test2": {
                "maybe" : false,
                "test3": { "nothing" : true }
            }
        }
    },
    {
        "key" : 2,
        "prop1": "y",
        "test" : { "one": 1 }
    }],
    arr2 = [
        {
            "key" : 1,
            "prop2" : "y",
            "test" : { "two" : 2 }
        },
        {
            "key" : 2,
            "prop2" : "z",
            "test" : { "two": 2 }
        }];
console.log(mergeByKey(arr1, arr2, "key"));

结果

/*
Object
    key: 1
    prop1: "x"
    prop2: "y"
    test: Object
        one: 1
        test2: Object
            maybe: false
            test3: Object
                nothing: true
                __proto__: Object
            __proto__: Object
        two: 2
        __proto__: Object
    __proto__: Object
Object
    key: 2
    prop1: "y"
    prop2: "z"
    test: Object
        one: 1
        two: 2
        __proto__: Object
    __proto__: Object
*/

这会正确合并对象以及所有子对象。此解决方案假定具有匹配 keys 的对象具有相同的层次结构。它也不处理两个数组的合并。

fiddle

关于javascript - 如何在 Javascript 中合并对象数组？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/24847190/