Javascript 使用lodash的2个阵列的并集

我有以下两个阵列：

    arr1 = [
            {
                "key1": "Value1"
            },
            {
                "key2": "Value2"
            },
            {
                "key3": "Test3"
            },
            {
                "key4": "Test4"
            },
            {
                "key5": "Test5"
            },
            {
                "key6": "Test6"
            },
            {
                "key7": "Test7"
            }
        ]

第二个数组是

    arr2 = [
            {
                "key3": "Value3-changed"
            },
            {
                "key6": "Value6-changed"
            }

        ]

现在，一旦我加入2个数组，结果将是

   resultArr = [
        {
            "key1": "Value1"
        },
        {
            "key2": "Value2"
        },
        {
            "key3": "Value3-changed"
        },
        {
            "key4": "Test4"
        },
        {
            "key5": "Test5"
        },
        {
            "key6": "Value6-changed"
        },
        {
            "key7": "Test7"
        }
    ]

我看到了解决问题的办法。但就我的情况而言，关键是不同的。有解决这个问题的建议吗？我试着使用lodash u.unionBy和u.uniqWith，但没有得到想要的结果

谢谢，

---

安迪

不需要洛达斯。首先将两个数组减少为一个对象，随后出现的键将覆盖任何先前设置的值：

const obj = [...arr1, ...arr2].reduce((acc,cur) => Object.assign(acc, cur), {});
// {key1: value1, ...}

编辑，更简单：

const obj = Object.assign({}, ...arr1, ...arr2);

然后将关键点映射回一组对象：

const resultArray = Object.keys(obj)
   .sort() // if alphanumeric order of keys matters to you
   .map(key => { const o={}; o[key]=obj[key]; return o;});

---

您可以在没有lodash的情况下这样做：

（推送新对象，或更新现有对象

让arr1=[
{
“键1”：“值1”
},
{
“键2”：“值2”
},
{
“key3”：“Test3”
},
{
“key4”：“Test4”
},
{
“键5”：“Test5”
},
{
“key6”：“Test6”
},
{
“key7”：“Test7”
},
]
设arr2=[
{
“键3”：“值3已更改”
},
{
“键6”：“值6已更改”
},
{
“键10”：“值10新”
},
]
对于（让arr2的obj）{
让keyName=Object.keys（obj）[0]；
让existingObject=arr1.find（x=>Object.keys（x）[0]==keyName）；
如果（现有对象）{
//存在具有相同密钥的对象。因此我们更新它。
existingObject[keyName]=对象[keyName]；
}否则{
//找不到密钥，这是一个新对象，让我们添加它。
arr1.推力（obj）；
}
}
console.log（arr1）

使用本机javascript，您可以在&map函数中为..使用

实现相同的功能


var arr1=[{
“键1”：“值1”
},
{
“键2”：“值2”
},
{
“key3”：“Test3”
},
{
“key4”：“Test4”
},
{
“键5”：“Test5”
},
{
“key6”：“Test6”
},
{
“key7”：“Test7”
}
]
var arr2=[{
“键3”：“值3已更改”
},
{
“键6”：“值6已更改”
}
];
//从两者获取对象关键点
var getArr2Keys=arr2.map（函数（项）{
用于（让关键点进入项目）{
返回键；
}
});
var getArr1Keys=arr1.map（函数（项）{
用于（让关键点进入项目）{
返回键；
}
});
//迭代新创建的对象并检查键是否匹配
forEach（函数（itemArr2，索引）{
var x=getArr1Keys.findIndex（函数（itemArr1）{
返回itemArr2===itemArr1；
})
//用arr2中的值替换arr1的键值
arr1[x][itemArr2]=arr2[index][itemArr2]
})
console.log（arr1）
如果您有权访问
…
排列运算符：

map(chunk(toPairs(assign(...arr1, ...arr2))), fromPairs)

否则：

map(chunk(toPairs(spread(assign)(concat(arr1, arr2)))), fromPairs)

这是丑陋的，但做的工作


Lodash插件
混合({
“assignPairsChunkAndMapObjects”：函数（arr1、arr2）{
返回0.map（0.chunk（0.toPairs（0.assign（…arr1，…arr2）），0.fromPairs）；
},
“assignPairsChunkAndMapObjectsChained”：函数（arr1、arr2）{
返回u.chain（u.assign（…arr1，…arr2））.toPairs（）.chunk（）.map（u.fromPairs）.value（）；
}
});
您可以创建一个mixin来迭代第一个数组并将其与第二个数组合并


混合({
“合并对象列表”：函数（arr1、arr2）{
返回映射（arr1，函数（obj）{
Object.keys（obj.forEach）（key=>{
var found=u.find（arr2，x=>Object.keys（x）.indexOf（key）>-1）；
如果（找到！=null）{
返回合并（obj，found）；
}
});
返回obj；
});
}
});
变量arr1=[
{“key1”：“Value1”}，
{“key2”：“Value2”}，
{“key3”：“Test3”}，
{“key4”：“Test4”}，
{“key5”：“Test5”}，
{“key6”：“Test6”}，
{“key7”：“Test7”}
];
var arr2=[
{“key3”：“Value3已更改”}，
{“key6”：“Value6已更改”}
];
var arr3=u2;.mergeObjectList（arr1，arr2）；
document.body.innerHTML=JSON.stringify（arr3，null，4）；
body{font-family:monospace；white-space:pre；}
您还可以使用和数组方法

在ES5中


var arr1=[{
“键1”：“值1”
}, {
“键2”：“值2”
}, {
“key3”：“Test3”
}, {
“key4”：“Test4”
}, {
“键5”：“Test5”
}, {
“key6”：“Test6”
}, {
“key7”：“Test7”
}],
arr2=[{
“键3”：“值3已更改”
}, {
“键6”：“值6已更改”
}],
键=''；
var结果=arr1.map（函数（项）{
key=Object.key（项）[0]；
返回arr2.find（函数v）{
返回v[键]
})| |项目；
});
console.log（结果）
您能将代码复制到一个代码段中，以便我们看到它可能出错的地方吗？为什么这需要一个数组？没有lodash，您可以concat 2个数组，如果需要union语义，还可以删除replices元素。请参见例如：可能重复的也可能重复：在我看来，它们应该是唯一的，即kearr2中的y3覆盖了arr1中的key3，等等。那么31piy，你是什么意思？所以要清楚，这个代码中只有唯一的键。你说应该有重复的键吗？看看OP的例子，你是对的，似乎不应该有重复的，而第二个数组中的值应该覆盖第一个数组中的值。是的，这是正确的这就是这里发生的事情。obj将只拥有每个key.Object.assign（{key3:'old'}，{key3:'new'}）=>{key3:'new'}但这会创建一个包含所有键的单一对象。OP希望原始对象中的每个对象都有一个数组，其中包含更新的键值对。我将您的代码转换为Lodash插件，并添加了一个链接版本，以实现相同的目的。感谢@Pac0的帮助。我接受了您的答案。