Question

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

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

我需要将其作为csv发送，因此我需要在该子数组上进行映射和迭代，并将其展平为它们的ain对象，如下所示：

{
    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是一个字符串数组，phoneNumbers是一个字符串数组，otherliens是一个对象数组。

任何帮助将不胜感激并牢记在心，因为批量数据传输和csvs最终将具有固定数量的列，我不介意null值，所以我想您会使用最长的子数组长度并使用在所有其他对象中。

完整代码

 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,  
            })
           } );

Answer 1

使用循环从嵌套数组分配属性，而不是对项目数量进行硬编码。

我也不认为需要条件表达式。由于每个输入元素都直接映射到一个输出元素，因此将不需要result[i]进行更新。

result = prospects.map(({fullName, firstName, lastName, deliveryAddress, city, state,zip4, county, plaintiff, amount, age, dob, ssn, otherliens, phones, emailAddresses}) => {
  let obj = {
    fullName: fullName,
    First_Name: firstName,
    Last_Name: lastName,
    Delivery_Address: deliveryAddress,
    City: city,
    State: state,
    Zip_4: zip4,
    County: county,
    plaintiff: plaintiff,
    Amount: amount,
    age: age,
    dob: dob,
    ssn: ssn
  };
  otherliens.forEach(({plaintiff, amount}, i) => {
    obj[`plaintiff${i+2}`] = plaintiff;
    obj[`amount${i+1}`] = amount;
  });
  phones.forEach((phone, i) => obj[`phone${i+1}`] = phone);
  emailAddresses.forEach((addr, i) => obj[`emailAddress${i+1}`] = addr);
  return obj;
})

将嵌套数组映射到父对象的键值对

1 个答案: