Javascript 将嵌套数组映射到父对象'；s键值对

我有一个对象数组，看起来像：

{
    name: 'steve',
    plaintiff:'IRS'
    amount: 5000,
    otherliens:[
        {
            amount:5000,
            plaintiff:'irs'
        },
        {amount:5000, 
         plaintiff:'irs'
        }
    ]
}

我需要将其作为csv发送，因此我需要映射并迭代此子阵列，并将其展平到对象中，如下所示：

{
    name:'steve',
    plaintiff:'irs',
    amount:5000,
    plaintiff2:'irs',
    amount2:5000,
    plaintiff3:'irs',
    amount3:5000
}

我通常用于执行此过程的代码是通过使用

arr.map（a，i=>{a[i]？a[i].amount=a[i].amount}）将原始数组的内容映射到一个新数组中

我能够通过简单地猜测大量条目（请参见电话和电子邮件）来处理基于字符串的子数组，因为如果我返回null，它只会返回空白，在csv中，这并不是最糟糕的事情。但我不能这样做，因为访问不存在的元素的子属性显然是行不通的。这是im使用的映射，其中emailAddresses是一个字符串数组，PhoneNumber是一个字符串数组，Otherlien是一个对象数组

任何帮助都将被感激并牢记在心，因为大容量数据传输和CSV最终将有固定数量的列，我不介意空值，所以我猜您将采用最长的子数组长度，并在所有其他对象中使用它

完整代码

 prospects.map((list, i) => {

      result[i] 
        ? (result[i].fullName = list.fullName)
          (result[i].First_Name = list.firstName)
          (result[i].Last_Name = list.lastName)
          (result[i].Delivery_Address = list.deliveryAddress)
          (result[i].City = list.city)
          (result[i].State = list.state)
          (result[i].Zip_4 = list.zip4)
          (result[i].County = list.county)
          (result[i].plaintiff= list.plaintiff)
          (result[i].Amount = list.amount)
          (result[i].age = list.age)
          (result[i].dob= list.dob)
          (result[i].snn= list.ssn)   
          (result[i].plaintiff2= list.otherliens[1].plaintiff )
          (result[i].filingDate2= list.otherliens[1].filingDate)
          (result[i].amount2= list.otherliens[1].amount )
          (result[i].plaintiff3= list.otherliens[2].plaintiff)
          (result[i].filingDate3= list.otherliens[2].filingDate )
          (result[i].amount3= list.otherliens[2].amount )
          (result[i].amount4= list.otherliens[3].amount)
          (result[i].plaintiff4= list.otherliens[3].plaintiff )
          (result[i].filingDate4= list.otherliens[3].filingDate )
          (result[i].phone1 = list.phones[0])
          (result[i].phone2 = list.phones[1])
          (result[i].phone3 = list.phones[2])
          (result[i].phone4 = list.phones[3])
          (result[i].phone5 = list.phones[4])
          (result[i].phone6 = list.phones[5])
          (result[i].phone7 = list.phones[6])
          (result[i].phone8 = list.phones[7])
          (result[i].phone9 = list.phones[8])
          (result[i].emailAddress1 = list.emailAddresses[0])
          (result[i].emailAddress2 = list.emailAddresses[1])
          (result[i].emailAddress3 = list.emailAddresses[2])
          (result[i].emailAddress4 = list.emailAddresses[3])
          (result[i].emailAddress5 = list.emailAddresses[4])
          (result[i].emailAddress6 = list.emailAddresses[5])
          (result[i].emailAddress7 = list.emailAddresses[6])

        : (result[i] = {
              Full_Name: list.fullName ,
              First_Name: list.firstName,
              Last_Name: list.lastName,
              Delivery_Address: list.deliveryAddress,
              City: list.city,
              State: list.state,
              Zip_4: list.zip4,
              County: list.county,
              dob: list.dob,
              ssn:list.ssn,
              age:list.age,
              Amount: list.amount,
              plaintiff: list.plaintiff,         
              filingDate: list.filingDate,
              phone1:list.phones[0],
              phone2:list.phones[1],
              phone3:list.phones[3],
              phone4:list.phones[4],
              phone5:list.phones[5],
              phone6:list.phones[6],
              phone7:list.phones[7],      
              phone8:list.phones[8],
              emailAddress1:list.emailAddresses[0],
              emailAddress2:list.emailAddresses[1],
              emailAddress3:list.emailAddresses[2],
              emailAddress4:list.emailAddresses[3],
              emailAddress5:list.emailAddresses[4],
              emailAddress6:list.emailAddresses[5],
              plaintiff2: list.otherliens[1].plaintiff,
              amount2: list.otherliens[1].amount,
              filingDate2: list.otherliens[1].filingDate,
              plaintiff3: list.otherliens[2].plaintiff,
              filingDate3: list.otherliens[2].filingDate,
              amount3: list.otherliens[2].amount,
              plaintiff4: list.otherliens[3].plaintiff,
              amount4: list.otherliens[3].amount,
              filingDate4: list.otherliens[3].filingDate,  
            })
           } ); 

---

使用循环从嵌套数组中指定属性，而不是对项数进行硬编码

我也不认为有必要使用条件表达式。由于每个输入元素直接映射到输出元素，因此不会有需要更新的

result[i]

result=prospects.map（{fullName，firstName，lastName，deliveryAddress，city，state，zip4，country，原告，金额，年龄，dob，ssn，其他客户，电话，emailaddress}）=>{
设obj={
全名：全名，
名字：名字，
姓氏：姓氏，
送货地址：送货地址，
城市:城市,，
州:州,，
Zip_4:zip4，
县:县,，
原告:原告,，
金额:金额,，
年龄:年龄,，
多布：多布，
ssn:ssn
};
其他留置权。forEach（{原告，金额}，i）=>{
obj[`原告${i+2}`]=原告；
obj[`amount${i+1}`]=金额；
});
phones.forEach（（phone，i）=>obj[`phone${i+1}`]=phone）；
forEach（（addr，i）=>obj[`emailAddress${i+1}`]=addr）；
返回obj；
})

如果未使用返回值，则应使用

forEach

，而不是

map

。