Javascript 将两个对象分解为一个对象并连接特定键的好方法是什么？

给定两个具有不同但已知关键点的对象（可以设置，也可以不设置），使用这两个对象的特定关键点映射将它们组合成一个对象的好方法是什么

例如，

obj1

可以有键

itemA

、

itemB

和

itemC

。另一个

obj2

可以具有键

项a

、

项b

和

项c

，并具有优先权。这些键分别指的是相同的最终键

a

、

b

和

c

这就是我想出来的，但感觉不必要的复杂

//给定这些对象：
常量obj1={itemA:1，itemB:2，itemC:undefined}
const obj2={item_a:undefined，item_b:20，item_c:30}
//期望结果：{a:1，b:20，c:30}
const filter=obj=>Object.fromEntries(
Object.entries（obj.filter）（条目=>条目[1]）
)
常量序列化d1=（对象=>
（{itemA:a，itemB:b，itemC:c}=object）
&&过滤器（{a，b，c}））（obj1）
常量序列化d2=（对象=>
（{item_a:a，item_b:b，item_c:c}=object）
&&过滤器（{a，b，c}））（obj2）
const finalObject={…serialized1，…serialized2}
console.log（finalObject）
//{a:1，b:20，c:30}

我大致尝试为每个对象创建一个键映射，其中外键映射到本地键，然后合并

---

---

注意：提到的键名就是示例。实际上，它可以是任意的，就像

im维度

和

img res

中的一个被存储在一个名为

size

的键中，使用Stringify和Parse，我们可以实现这一点

constobj1={itemA:1，itemB:2}；
const obj2={item_b:20，item_c:30}；
let格式=（obj）=>{
返回JSON.parse（JSON.stringify（obj.toLowerCase（）.replace（/\”（\w*）（[a-c]{1}\：）/g，“\”$2”）；
}
设obj3={…格式（obj1），…格式（obj2）}
console.log（obj3）；

---

。作为控制台包装{max height:100%！important；top:0；}

使用Stringify和Parse，我们可以实现这一点

constobj1={itemA:1，itemB:2}；
const obj2={item_b:20，item_c:30}；
let格式=（obj）=>{
返回JSON.parse（JSON.stringify（obj.toLowerCase（）.replace（/\”（\w*）（[a-c]{1}\：）/g，“\”$2”）；
}
设obj3={…格式（obj1），…格式（obj2）}
控制台日志（obj3）
.as控制台包装{max height:100%！important；top:0；}
我找到了一个解决方案。您可以创建一个
映射
，将命名奇怪的键映射到它们的首选名称，并使用ES6将它们“重命名”为新对象。基本上，这意味着您可以使用变量作为键名，如下所示：

const obj={
[键]：值
}

因此，通过我们的
映射
，我们可以使用旧对象的值创建一个新键：

const obj={
[地图[键]]：对象[键]
}

为了对对象中的每个键自动执行此操作，我们可以将此函数与语法结合使用：

const映射器=（映射，对象）=>
对象键（obj）
.filter（key=>Boolean（obj[key]））
.减少（（附件，钥匙）=>
({
…acc，
…{[map[key]]：obj[key]}
}), {})

这是一个非常通用和可重用的功能。我们只需要提供
映射和输入对象。下面是一个基于原始问题数据的完整示例：


//给定这些对象：
常量obj1={itemA:1，itemB:2，itemC:undefined}
const obj2={item_a:undefined，item_b:20，item_c:30}
//期望结果：{a:1，b:20，c:30}
// ------
//将关键点映射到预定义属性
常数映射={
项目a：‘a’，
项目a：‘a’，
b项：‘b’，
b项：“b”，
项目c：‘c’，
第c项：“c”
}
常量映射器=（映射，对象）=>
对象键（obj）
.filter（key=>Boolean（obj[key]））
.减少（（附件，钥匙）=>
({
…acc，
…{[map[key]]：obj[key]}
}), {})
const keymap=mapper.bind（null，map）
常量属性={…键映射（obj1），…键映射（obj2）}
console.log（属性）
//{a:1，b:20，c:30}
我找到了一个解决办法。您可以创建一个
映射
，将命名奇怪的键映射到它们的首选名称，并使用ES6将它们“重命名”为新对象。基本上，这意味着您可以使用变量作为键名，如下所示：

const obj={
[键]：值
}

因此，通过我们的
映射
，我们可以使用旧对象的值创建一个新键：

const obj={
[地图[键]]：对象[键]
}

为了对对象中的每个键自动执行此操作，我们可以将此函数与语法结合使用：

const映射器=（映射，对象）=>
对象键（obj）
.filter（key=>Boolean（obj[key]））
.减少（（附件，钥匙）=>
({
…acc，
…{[map[key]]：obj[key]}
}), {})

这是一个非常通用和可重用的功能。我们只需要提供
映射和输入对象。下面是一个基于原始问题数据的完整示例：


//给定这些对象：
常量obj1={itemA:1，itemB:2，itemC:undefined}
const obj2={item_a:undefined，item_b:20，item_c:30}
//期望结果：{a:1，b:20，c:30}
// ------
//将关键点映射到预定义属性
常数映射={
项目a：‘a’，
项目a：‘a’，
b项：‘b’，
b项：“b”，
项目c：‘c’，
第c项：“c”
}
常量映射器=（映射，对象）=>
对象键（obj）
.filter（key=>Boolean（obj[key]））
.减少（（附件，钥匙）=>
({
…acc，
…{[map[key]]：obj[key]}
}), {})
const keymap=mapper.bind（null，map）
常量属性={…键映射（obj1），…键映射（obj2）}
console.log（属性）
//{a:1，b:20，c:30}
仅为澄清，如果itemX和item_x都存在，是否要使用较高的值？@Aaron否，第二个对象优先。一旦键被均衡，
{…serialized1，…serialized2}
就足够了。只是为了澄清您想要使用的内容