Javascript 合并两个对象数组，并覆盖键值

我正在尝试合并来自json的数据，这些数据以对象数组的形式出现。我在这里使用了下划线解决方案，但结果证明它并没有覆盖我现在也需要做的现有项

结果应该是数组1中所有项的顺序相同，由数组2覆盖，其中id=id。数组2中不存在的项应该推送到结果的末尾

第一个阵列：

[
 {id: 8, category: "A"}
 {id: 2, category: "D"}
 {id: 5, category: "C"}
 {id: 9, category: "B"}
]

第二个阵列：

[
 {id: 1, category: "X"}
 {id: 2, category: "Y"}
]

预期结果：

[
 {id: 8, category: "A"}
 {id: 2, category: "Y"}
 {id: 5, category: "C"}
 {id: 9, category: "B"}
 {id: 1, category: "X"}
]

您可以使用as闭包并存储此

id

的结果数组的索引

var first=[{id:8，类别：“A”}，{id:2，类别：“D”}，{id:5，类别：“C”}，{id:9，类别：“B”}，
second=[{id:12，类别：“X”}，{id:2，类别：“Y”}]，
结果=[第一，第二].reduce（（m=>（r，a）=>{
a、 forEach（o=>{
如果（m.has（o.id））{
r[m.get（o.id）]=o；
返回；
}
m、 设置（o.id，r.push（o）-1）；
});        
返回r；
})（新地图），[]）；
控制台日志（结果）

您可以使用as闭包并存储此

id

的结果数组的索引

var first=[{id:8，类别：“A”}，{id:2，类别：“D”}，{id:5，类别：“C”}，{id:9，类别：“B”}，
second=[{id:12，类别：“X”}，{id:2，类别：“Y”}]，
结果=[第一，第二].reduce（（m=>（r，a）=>{
a、 forEach（o=>{
如果（m.has（o.id））{
r[m.get（o.id）]=o；
返回；
}
m、 设置（o.id，r.push（o）-1）；
});        
返回r；
})（新地图），[]）；
控制台日志（结果）使用
过滤器
，
查找
和
concat

鉴于此

var arr1 = [
 {id: 8, category: "A"},
 {id: 2, category: "D"},
 {id: 5, category: "C"},
 {id: 9, category: "B"}
];
var arr2 = [
 {id: 12, category: "X"},
 {id: 2, category: "Y"}
];

如果订单不重要

var output = arr2.concat( 
        arr1.filter( s => 
            !arr2.find( t => t.id == s.id ) 
        )//end filter 
);//end concat

演示


var arr1=[{
id:8，
类别：“A”
},
{
id:2，
类别：“D”
},
{
id:5，
类别：“C”
},
{
id:9，
类别：“B”
}
];
var arr2=[{
id:12，
类别：“X”
},
{
id:2，
类别：“Y”
}
];
var输出=arr2.concat(
arr1.过滤器（s=>
！arr2.find（t=>t.id==s.id）
)//结束过滤器
); //端壳
控制台日志（输出）使用
过滤器
，
查找
和
concat

鉴于此

var arr1 = [
 {id: 8, category: "A"},
 {id: 2, category: "D"},
 {id: 5, category: "C"},
 {id: 9, category: "B"}
];
var arr2 = [
 {id: 12, category: "X"},
 {id: 2, category: "Y"}
];

如果订单不重要

var output = arr2.concat( 
        arr1.filter( s => 
            !arr2.find( t => t.id == s.id ) 
        )//end filter 
);//end concat

演示


var arr1=[{
id:8，
类别：“A”
},
{
id:2，
类别：“D”
},
{
id:5，
类别：“C”
},
{
id:9，
类别：“B”
}
];
var arr2=[{
id:12，
类别：“X”
},
{
id:2，
类别：“Y”
}
];
var输出=arr2.concat(
arr1.过滤器（s=>
！arr2.find（t=>t.id==s.id）
)//结束过滤器
); //端壳
控制台日志（输出）
您可以在
secondArray
上设置一个循环，并根据
id
为
firstArray
的
id
对象检查每个具有
id
值的对象。如果找到匹配项，则只需替换对象，否则按下对象：


var firstArray=[
{id:8，类别：“A”}，
{id:2，类别：“D”}，
{id:5，类别：“C”}，
{id:9，类别：“B”}
];
var secondArray=[
{id:12，类别：“X”}，
{id:2，类别：“Y”}
];
secondArray.forEach（（obj）=>{
var匹配=假；
对于（var i=0；i您可以在
secondArray
上设置一个循环，并将
id
值的每个对象与
id
值为
firstArray
的对象进行对比检查。如果找到匹配项，则只需替换对象，否则推送对象：


var firstArray=[
{id:8，类别：“A”}，
{id:2，类别：“D”}，
{id:5，类别：“C”}，
{id:9，类别：“B”}
];
var secondArray=[
{id:12，类别：“X”}，
{id:2，类别：“Y”}
];
secondArray.forEach（（obj）=>{
var匹配=假；
对于（var i=0；i您可以使用
forEach
迭代
second
数组。对于第一个数组中具有相同id的每个对象，更新
类别
，否则推入新数组


const first=[{id:8，类别：“A”}，{id:2，类别：“D”}，{id:5，类别：“C”}，{id:9，类别：“B”}]，
second=[{id:12，类别：“X”}，{id:2，类别：“Y”}]，
合并=[…第一]；
second.forEach（o=>{
让obj=first.find（（{id，category}）=>id==o.id）；
obj？obj.category=o.category:merged.push（{…o}）；
});
console.log（合并）；
您可以使用
forEach
在
第二个数组中迭代。对于第一个数组中具有相同id的每个对象，更新
类别
，否则推入新数组


const first=[{id:8，类别：“A”}，{id:2，类别：“D”}，{id:5，类别：“C”}，{id:9，类别：“B”}]，
second=[{id:12，类别：“X”}，{id:2，类别：“Y”}]，
合并=[…第一]；
second.forEach（o=>{
让obj=first.find（（{id，category}）=>id==o.id）；
obj？obj.category=o.category:merged.push（{…o}）；
});
console.log（合并）；
我认为reduce更好

first.reduce((res, item) => res.filter(i => i.id !== item.id).concat(item), second);

我认为减少更好

first.reduce((res, item) => res.filter(i => i.id !== item.id).concat(item), second);

我用下划线回答了我自己的问题。这可能不是最有效的

const newarr = _.map(arr1, obj1 => {
  const r = _.find(arr2, obj2 => {
    return obj1[match] === obj2[match]
  })
  if (typeof r === 'undefined') {
    return obj1
  } else {
    return r
  }
})
_.each(arr2, obj => {
  if (_.indexOf(arr1, _.findWhere(arr1, {id: obj.id})) === -1) { 
   newarr.push(obj) 
  }
})

我用下划线回答了我自己的问题。这可能不是最有效的

const newarr = _.map(arr1, obj1 => {
  const r = _.find(arr2, obj2 => {
    return obj1[match] === obj2[match]
  })
  if (typeof r === 'undefined') {
    return obj1
  } else {
    return r
  }
})
_.each(arr2, obj => {
  if (_.indexOf(arr1, _.findWhere(arr1, {id: obj.id})) === -1) { 
   newarr.push(obj) 
  }
})

这应该起作用：

const newArr = second.reduce((res, item) => res.filter(i => i.id !== item.id).concat(item), first);

这应该起作用：

const newArr = second.reduce((res, item) => res.filter(i => i.id !== item.id).concat(item), first);

这似乎没有先改变？这似乎没有先改变？