Javascript 通过替换另一个对象中的属性名创建新对象

因此，有很多问题涉及如何循环遍历对象并对属性名称进行简单更改，但我要解决的是有点棘手，非常感谢您的帮助

本质上，我想制作一个如下的对象：

{
   home_number: '1234',
   customer: {
     name: {
       last_name: 'Smith',
     },
   },
};

变成这个

{
   home_number: '1234',
   individual: {
     name: {
       lastName: 'Smith',
     },
   },
};

目前，我的职能如下

function restructure(obj) {
  let newObj = {};
  const newKeys = {
    fed_tax_id: 'federalTaxId',
    company_structure: 'companyStructure',
    home_number: 'homeNumber',
    customer: 'individual',
    first_name: 'firstName',
    last_name: 'lastName',
  }
}
  for(let key in obj){
    if (typeof obj[key] === 'object') {
      restructure(obj[key])
    }
    if(Object.hasOwnProperty.call(newKeys, key)){
      let newProperty = newKeys[key]
      newObj[newProperty] = obj[key]
    }
    if(!Object.hasOwnProperty.call(newKeys, key)){
      newObj[key] = obj[key]
    }
return newObj;
  }

目前我正在努力解决的一件事是删除需要更改的键（我创建了newKeys对象，以显示需要更改的键以及它们需要更改的内容）。即，在这种情况下，当客户更改为个人时，它也会将“姓氏”更改为“姓氏”

以我目前的功能，对象返回时的状态如下：

{ homeNumber: '1234' }

---

谢谢：）如果已经有人问过了，请告诉我，但是在搜索了所有地方后，我找不到一个与此足够接近的问题。

由于

restructure

返回新对象，您需要分配递归调用

restructure

的结果，否则它将无法使用，这就是当前代码中发生的情况

但映射条目数组可能更容易—如果对象具有该键，则用对象上的关联值替换条目中的键，然后将条目转换回具有

对象的对象。fromEntries

：

const newKeys={
fed_tax_id:'federalTaxId'，
公司结构：“公司结构”，
家庭号码：“家庭号码”，
顾客：“个人”，
名字：“名字”，
姓氏：“姓氏”，
};
const restructure=obj=>Object.fromEntries(
Object.entries（obj.map）(
（[key，val]）=>[
新钥匙[钥匙]| |钥匙，
typeof val=='object'&&val！==null？重组（val）：val
]
)
);
console.log（重新构造）({
家庭电话号码：“1234”，
客户：{
姓名：{
姓：“史密斯”，
},
},
}));您只需检查own属性和实际对象，以防止分配非own属性

对于所有属性，可以首先使用新键，如果不存在值，则使用实际键作为默认值

然后，您需要指定递归调用的结果，如果不是对象，则只指定值


功能重组（obj）{
设newObj={}；
const newKeys={fed_tax_id:'federalTaxId'，company_structure:'companyStructure'，home_number:'homeNumber'，customer:'individual'，first_name:'firstName'，last_name:'lastName'}；
用于（输入obj）{
如果（！obj.hasOwnProperty（key））继续；
newObj[newKeys[key]| | key]=obj[key]&&typeof-obj[key]=“object”
？重组（obj[关键]）
：obj[键]；
}
返回newObj；
}
log（重新构造（{home_number:'1234'，customer:{name:{last_name:'Smith'}}}））
您可以使用
Object.entries
和
Object.fromEntries
，
另外，只创建一次newKeys对象，而不是每次调用函数时都创建它


const newKeys={
fed_tax_id:'federalTaxId'，
公司结构：“公司结构”，
家庭号码：“家庭号码”，
顾客：“个人”，
名字：“名字”，
姓氏：“姓氏”，
}
功能重组（obj）{
let entries=Object.entries（obj.map）（[key，val]）=>{
val=typeof val=='object'&&！Array.isArray（val）？重新构造（val）：val
返回[newKeys[key]| | key，val]
});
返回对象.fromEntries（entries）
}
console.log（重新构造）({
家庭电话号码：“1234”，
客户：{
姓名：{
姓：“史密斯”，
},
},
}))
您可以使用
delete
从对象中删除属性

注意：我的函数将修改原始对象。如果要复制对象，请确保使用
JSON
方法进行深度复制


const newKeys={
fed_tax_id:'federalTaxId'，
公司结构：“公司结构”，
家庭号码：“家庭号码”，
顾客：“个人”，
名字：“名字”，
姓氏：“姓氏”，
}
常量对象={
家庭电话号码：“1234”，
个人：{
姓名：{
姓氏：“史密斯”，
},
},
};
功能重组（obj）{
for（让k在obj中）{
if（对象的类型[k]=“对象”&&&！Array.isArray（对象[k]））{
重组（obj[k]）；
}
if（新键[k]）{
obj[newkey[k]]=obj[k]；
删除obj[k]；
}
}
}
重组（obj）；
log（obj）
我将把关键转换技术与应用于对象的代码分开。在这段代码中，我们编写了一个通用的
rekey
函数，它接受一个键转换函数，并返回一个接受对象的函数，在键上递归运行该函数

因此，如果您想将所有的snake-case键转换为camel-case键，我们可以传递一个简单的基于正则表达式的转换函数，如下所示：

{
   home_number: '1234',
   customer: {
     name: {
       last_name: 'Smith',
     },
   },
};


const-rekey=（fn）=>（obj）=>
obj的类型==“对象”
? Object.fromEntries(
Object.entries（obj.map）（[k，v]）=>[fn（k），rekey（fn）（v）]）
)
：obj
常量snakotocamel=（str）=>
str.replace（/_（[a-z]）/g，（_，c）=>c.toUpperCase（））
const obj={home_number:'1234'，customer:{name:{last_name:'Smith'}}
控制台日志(
rekey（骆驼）（obj）
)
它仍然是
“last\u name”
而不是答案中的
lastName
。这是一个很好的解决方案，但是我应该提到我也在节点中工作，因为我刚刚发现了
对象。fromEntries
仅在节点12及以上的版本中工作（以前使用的是v10）。