Javascript 如何将对象中的嵌套数组转换为一个由逗号分隔的串联字符串值？

我有以下示例数组：

mainArray = [
    {id: 15475, name: 'Ali', gender: 'Male', addresses: [
      {address1: 'Lebanon'}, 
      {address2: 'USA'}]
    },
    {id: 15475, name: 'Emily', gender: 'Female', addresses: [
      {address1: 'UK'}, 
      {address2: 'France'}]
    },
];

我需要将其转换为如下内容：

mainArray = [
    {id: 15475, name: 'Ali', gender: 'Male', addresses: 'Lebanon, USA'},
    {id: 15475, name: 'Emily', gender: 'Female', addresses: 'UK, France }
];

在本例中，我将

mainArray

的a元素中的所有嵌套数组添加到一个字符串值中

到目前为止，我所做的是提取了

mainArray

的键名：

extractedIndexes = ['id', 'name', 'gender', 'addresses'];

并循环检查

mainArray

中每个元素的类型，如果它是一个对象，我将把嵌套数组的值合并成一个字符串：

for (const idx of this.extractedIndexes) {
  console.log(idx)
  this.mainArray.forEach((elem) => {
    let newItem = '';
    if (typeof (elem[idx]) == 'object') {
      elem[idx] = Object.keys(elem[idx]).forEach((key) => {
        console.log(elem[idx][key])
        // Add it to the field
      })
      console.log(elem[idx])
    }
  })
}
console.log(this.mainArray)

此行

console.log（elem[idx][key]）

始终返回以下内容：

{address1: "Lebanon"}

{address2: "USA"}

{address1: "UK"}

{address2: "France"}

if (typeof (elem[idx]) == 'object') {
  elem[idx] = elem[idx].toString().split(',')
  // Add it to the field
  console.log(elem[idx])
}

请注意，这里的

address1

和

address2

都是简单的示例，因为我的真实数据包含多个嵌套数组，每个数组都有不同的新键名

我试着做到以下几点：

{address1: "Lebanon"}

{address2: "USA"}

{address1: "UK"}

{address2: "France"}

if (typeof (elem[idx]) == 'object') {
  elem[idx] = elem[idx].toString().split(',')
  // Add it to the field
  console.log(elem[idx])
}

但是它返回了

[对象，对象]

那么，如何将嵌套数组转换为单个串联字符串值呢

---

这是一个。

只需使用

映射

并使用

对象。值

从对象获取值：

mainArray.map(({addresses, ...rest}) => ({...rest, addresses: 
    addresses.map(s => Object.values(s)).join(', ')}) );

例如：

let main数组=[
{id:15475，姓名：“阿里”，性别：“男性”，地址：[
{地址1:'黎巴嫩'}，
{地址2:'美国'}]
},
{id:15475，姓名：'Emily'，性别：'Female'，地址：[
{地址1:'英国'}，
{地址2:'法国'}]
},
];
const result=mainArray.map（（{addresses，…rest}）=>（{…rest，addresses:addresses.map（s=>Object.values））.join（'，'）}）；
控制台日志（结果）只需使用
映射
并使用
对象。值
从对象获取值：

mainArray.map(({addresses, ...rest}) => ({...rest, addresses: 
    addresses.map(s => Object.values(s)).join(', ')}) );

例如：


let main数组=[
{id:15475，姓名：“阿里”，性别：“男性”，地址：[
{地址1:'黎巴嫩'}，
{地址2:'美国'}]
},
{id:15475，姓名：'Emily'，性别：'Female'，地址：[
{地址1:'英国'}，
{地址2:'法国'}]
},
];
const result=mainArray.map（（{addresses，…rest}）=>（{…rest，addresses:addresses.map（s=>Object.values））.join（'，'）}）；
控制台日志（结果）
如果键以
address
开头，并且值不是对象，则可以使用递归函数获取可在任何嵌套结构上工作的地址，并获取值


const data=[{“id”：15475，“name”：“Ali”，“gender”：“Male”，“address1”：“leban”}，{“address2”：“USA”}，{“id”：15475，“name”：“Emily”，“gender”：“Female”，“address1”：“UK”}，{“address2”：“France”}]
常数单位=（数据，上一个=“”）=>{
设sep=prev？，：“
让结果=“”；
for（让我输入数据）{
if（数据类型[i]=“对象”）{
结果+=平坦（数据[i]，上一个+结果）
}else if（i.startsWith（'address'））{
结果+=sep+数据[i]
}
}
返回结果
}
const result=data.map(({
地址，
休息
}) =>
（{……休息，
地址：平面（地址）
}))
console.log（result）
如果键以
address
开头，并且值不是对象，则可以使用递归函数获取可在任何嵌套结构上工作的地址，并获取值


const data=[{“id”：15475，“name”：“Ali”，“gender”：“Male”，“address1”：“leban”}，{“address2”：“USA”}，{“id”：15475，“name”：“Emily”，“gender”：“Female”，“address1”：“UK”}，{“address2”：“France”}]
常数单位=（数据，上一个=“”）=>{
设sep=prev？，：“
让结果=“”；
for（让我输入数据）{
if（数据类型[i]=“对象”）{
结果+=平坦（数据[i]，上一个+结果）
}else if（i.startsWith（'address'））{
结果+=sep+数据[i]
}
}
返回结果
}
const result=data.map(({
地址，
休息
}) =>
（{……休息，
地址：平面（地址）
}))
console.log（结果）
{id:15475，姓名：'Ali'，性别：'Male'，地址：[
{地址1:'黎巴嫩'}，
{地址2:'美国'}]
},
{id:15475，姓名：'Emily'，性别：'Female'，地址：[
{地址1:'英国'}，
{地址2:'法国'}]
},
];

函数toString（arro）{
返回arro.reduce(
（acc、rec）=>{
返回[…acc，对象值（rec）]
}, []
).join（“，”）
}
const res=mainArray.map(
它=>{
返回Object.keys（it.reduce）(
（附件，项目）=>{
如果（它的类型[项目]=“对象”）{
返回{…acc[item]：toString（it[item]）}
}
return{…acc[item]：it[item]}
}, {}
)
}
)```

{id:15475，姓名：“阿里”，性别：“男性”，地址：[
{地址1:'黎巴嫩'}，
{地址2:'美国'}]
},
{id:15475，姓名：'Emily'，性别：'Female'，地址：[
{地址1:'英国'}，
{地址2:'法国'}]
},
];

函数toString（arro）{
返回arro.reduce(
（acc、rec）=>{
返回[…acc，对象值（rec）]
}, []
).join（“，”）
}
const res=mainArray.map(
它=>{
返回Object.keys（it.reduce）(
（附件，项目）=>{
如果（它的类型[项目]=“对象”）{
返回{…acc[item]：toString（it[item]）}
}
return{…acc[item]：it[item]}
}, {}
)
}
)```

在我不知道密钥名称的通用数组上，它不起作用。这里假设只有一个字段

地址

。我在同一个堆栈blitz中添加了一个函数，你能检查一下吗？它在我不知道键名的广义数组中不起作用。这里假设只有一个字段

地址

。我在同一个堆栈blitz中添加了一个函数，你能检查一下吗？