Javascript 比较两个对象数组并用另一个对象替换一个对象

我有一个工作函数，它将一个对象数组

customData

附加到另一个对象数组

testData

的末尾。如果两个数组中都出现了具有相同属性

名称

值的对象，则将删除

testData

对象，并将其替换为结果数组中的

customData

对象。

customData

对象采用上一个

testData

对象的顺序

这是我的尝试，但是，我想知道是否有更好的方法也很容易阅读（es6）

谢谢

导出默认函数App（）{
常数testData=[
{显示：“1”，名称：“TEST1”}，
{显示：“2”，名称：“TEST2”}
];
常量自定义数据=[
{display:“CUSTOM_1”，name:“TEST1”，CUSTOM:“YES”}，
{display:“CUSTOM_3”，name:“TEST3”，CUSTOM:“YES”}
];
设i=0；
const newTestData=testData；
设newCustomData=customData；
而（ix.name==view.name）；
如果（索引>=0）{
newTestData[index]=客户数据[i]；
newCustomData.拼接（i，1）；
}
i+=1；
}
const concatData=newTestData.concat（newCustomData）；
console.log（concatData）
返回null；
}

不改变数组，不需要将它们分配给新变量（无论如何也不会复制数组）。如果您希望使用简洁的ES6代码，请跳过while循环-有许多等价物。这里有一个例子：

您没有定义“更好的方式”，但我会将其解释为“性能和可读性最佳”。在下面的方法中，我使用一个过程填充地图，另一个过程在需要时使用

customData

覆盖地图条目，最后使用

Object.values（）

（技术上是第三个过程）生成结果。这是O（n）（无嵌套循环）与O（n^2）实现的对比

const testData=[
{显示：“1”，名称：“TEST1”}，
{显示：“2”，名称：“TEST2”}
];
常量自定义数据=[
{display:“CUSTOM_1”，name:“TEST1”，CUSTOM:“YES”}，
{display:“CUSTOM_3”，name:“TEST3”，CUSTOM:“YES”}
];
设map={}；
testData.forEach（item=>map[item.name]=item）；
customData.forEach（item=>map[item.name]=item）；
常量结果=对象值（映射）；
控制台日志（结果）不会改变数组，不需要将它们分配给新变量（无论如何也不会复制数组）。如果您希望使用简洁的ES6代码，请跳过while循环-有许多等价物。这里有一个例子：

您没有定义“更好的方式”，但我会将其解释为“性能和可读性最佳”。在下面的方法中，我使用一个过程填充地图，另一个过程在需要时使用
customData
覆盖地图条目，最后使用
Object.values（）
（技术上是第三个过程）生成结果。这是O（n）（无嵌套循环）与O（n^2）实现的对比


const testData=[
{显示：“1”，名称：“TEST1”}，
{显示：“2”，名称：“TEST2”}
];
常量自定义数据=[
{display:“CUSTOM_1”，name:“TEST1”，CUSTOM:“YES”}，
{display:“CUSTOM_3”，name:“TEST3”，CUSTOM:“YES”}
];
设map={}；
testData.forEach（item=>map[item.name]=item）；
customData.forEach（item=>map[item.name]=item）；
常量结果=对象值（映射）；
控制台日志（结果）代码背后的逻辑是正确的。
这几乎相同，但没有显式循环：


const testData=[
{显示：“1”，名称：“TEST1”}，
{显示：“2”，名称：“TEST2”}
];
常量自定义数据=[
{display:“CUSTOM_1”，name:“TEST1”，CUSTOM:“YES”}，
{display:“CUSTOM_3”，name:“TEST3”，CUSTOM:“YES”}
];
Array.prototype.uniqueWith=函数（比较器）{
返回这个。减少（（a，c，i）=>{
常数j=a.slice（i+1）.findIndex（e=>comparator（e，c））；
如果（j！=-1）{
a[i]=a[i+j+1]；
a、 接头（i+j+1,1）；
}
返回a；
}，这个）；
}
常量eqByName=（a，b）=>a.name==b.name；
const result=[…testData，…customData].uniqueWith（eqByName）；
控制台日志（结果）代码背后的逻辑是正确的。
这几乎相同，但没有显式循环：


const testData=[
{显示：“1”，名称：“TEST1”}，
{显示：“2”，名称：“TEST2”}
];
常量自定义数据=[
{display:“CUSTOM_1”，name:“TEST1”，CUSTOM:“YES”}，
{display:“CUSTOM_3”，name:“TEST3”，CUSTOM:“YES”}
];
Array.prototype.uniqueWith=函数（比较器）{
返回这个。减少（（a，c，i）=>{
常数j=a.slice（i+1）.findIndex（e=>comparator（e，c））；
如果（j！=-1）{
a[i]=a[i+j+1]；
a、 接头（i+j+1,1）；
}
返回a；
}，这个）；
}
常量eqByName=（a，b）=>a.name==b.name；
const result=[…testData，…customData].uniqueWith（eqByName）；
控制台日志（结果）这就是您正在寻找的函数类型吗


const result=App（myTestData（），myCustData（））；
控制台日志（结果）；
功能应用程序（testData、custData）{
//`indByName`返回带有匹配名称的对象的索引（在arr中）（如果不匹配则返回-1）
常量indByName=（arr，name）=>
ind=arr.findIndex（o=>o.name==name）；
let custInd；//输出'indByName'的标识符`
const custDataClone=custData.slice（）；//防止“custData”发生变异`
返回testData.map（项=>(
//使用indByName获取相应自定义项的索引
custInd=indByName（custDataClone，item.name），
//如果合适，将相应的自定义项移动到testData中
custInd>-1？custDataClone.splice（custInd，1）[0]：项
//将custDataClone中的剩余项追加到新阵列
)).concat（custDataClone）
}
函数myTestData（）{
返回[
{显示：“1”，名称：“TEST1”}，
{显示：“2”，名称：“TEST2”}
];
}
函数myCustData（）{
返回[
{显示：“客户”
export default function App() {
  const testData = [
    { display: "1", name: "TEST1" },
    { display: "2", name: "TEST2" }
  ];

  const customData = [
    { display: "CUSTOM_1", name: "TEST1", custom: "YES" },
    { display: "CUSTOM_3", name: "TEST3", custom: "YES" }
  ];

  let i = 0;
  const newTestData = testData;
  let newCustomData = customData;

  while (i < customData.length) {
    const view = customData[i];
    const index = testData.findIndex(x => x.name === view.name);

    if (index >= 0) {
      newTestData[index] = customData[i];
      newCustomData.splice(i, 1);
    }
    i += 1;
  }

  const concatData = newTestData.concat(newCustomData);
  console.log(concatData)

  return null;
}