Javascript 如何从另一个数组返回数组数据？

我有数组数据，在迭代之后，我希望得到另一个结构的新数组

这是我的源阵列：

let oldArr = [
 {
  "20200714": [
    {      
      "StartDate": "2020-07-14T11:05:31.151687000",   
      "EndDate": "2020-07-14T12:11:59.673687000",                   
    },
    {      
      "StartDate": "2020-07-14T13:05:31.151687000",      
      "EndDate": "2020-07-14T14:11:59.673687000",                  
    },
  ],
  "20200715": [
    {         
      "StartDate": "2020-07-15T14:05:31.151687000",        
      "EndDate": "2020-07-15T15:11:59.673687000",                        
    }
  ]
 }
]

输出应如下所示：

      [
        {
          x: '20200714',
          y: [          
            '2020-07-14T11:05:31.151687000',
            '2020-07-14T12:11:59.673687000',       
          ]              
        },
        {
          x: '20200714',
          y: [          
            '2020-07-14T13:05:31.151687000',
            '2020-07-14T13:05:31.151687000',       
          ]              
        },
        {
          x: '20200715',
          y: [          
            '2020-07-15T14:05:31.151687000',
            '2020-07-15T15:11:59.673687000',       
          ]              
        }           
      ]

我试图通过map（）之类的方式迭代数组，但我不知道如何正确执行

let newArr = oldArr.map((key) => {
  return {
    x: key,
    y: [          
      key.StartDate,
      key.EndDate                 
    ]
  }
)

---

提前感谢

您的源实际上是一个由一个对象组成的数组，因此您希望使用

object.entries

获得一个数组，然后使用嵌套循环在

y

值的内部数组上循环这些条目

由于有三个嵌套循环，如果您只创建一个数组并在

forEach

中推送到它，而不是嵌套多个

reduce

s，代码会更简单：

让oldArr=[{
"20200714": [{
“起始日期”：“2020-07-14T11:05:31.151687000”，
“结束日期”：“2020-07-14T12:11:59.673687000”，
},
{
“起始日期”：“2020-07-14T13:05:31.151687000”，
“结束日期”：“2020-07-14T14:11:59.673687000”，
},
],
"20200715": [{
“起始日期”：“2020-07-15T14:05:31.151687000”，
“结束日期”：“2020-07-15T15:11:59.673687000”，
}]
}]
让newArr=[]
oldArr.forEach（outerObject=>Object.entries（outerObject）
.forEach（[键，项]）=>
items.forEach（（item）=>newArr.push({
x:钥匙，
y:[项目开始日期，项目结束日期]
}))
)
)
console.log（newArr）

您需要组合多个减速器以访问正确的数据：

让oldArr=[
{
"20200714": [
{      
“起始日期”：“2020-07-14T11:05:31.151687000”，
“结束日期”：“2020-07-14T12:11:59.673687000”，
},
{      
“起始日期”：“2020-07-14T13:05:31.151687000”，
“结束日期”：“2020-07-14T14:11:59.673687000”，
},
],
"20200715": [
{         
“起始日期”：“2020-07-15T14:05:31.151687000”，
“结束日期”：“2020-07-15T15:11:59.673687000”，
}
]
}
]
const newArr=oldArr.reduce（（mainac，currItem）=>[…mainAcc，…Object.keys（currItem）.reduce（（acc，currKey）=>{
const vals=当前项目[当前键]；
返回[
…acc，
vals.map（（v）=>（{x:currKey，y:[v.StartDate，v.EndDate]}），
];
}, [])], []);
控制台日志（newArr）我认为问题是因为你有一个数组，里面只有一个对象。因此，当您使用数组映射时，您的“键”是数组的位置0，我认为您可以这样做以获得特定的结果：

Object.keys(oldArr).reduce((acc, current) => {
    console.log(acc, current)
    oldArr[current].forEach((objWithDate) => {
        acc.push({
            x: current,
            y: [objWithDate.StartDate, objWithDate.EndDate]
        })
    })
    return acc
}, [])

我真的不知道你的node版本，也不知道这是否适用于web，但我希望这对你有用。祝您度过愉快的一天
您可以对

执行正常的

循环，以迭代对象键。其实很简单：

var obj = [{
    "20200714": [{
            "StartDate": "2020-07-14T11:05:31.151687000",
            "EndDate": "2020-07-14T12:11:59.673687000",
        },
        {
            "StartDate": "2020-07-14T13:05:31.151687000",
            "EndDate": "2020-07-14T14:11:59.673687000",
        },
    ],
    "20200715": [{
        "StartDate": "2020-07-15T14:05:31.151687000",
        "EndDate": "2020-07-15T15:11:59.673687000",
    }]
}];

var newObj = [];

for (var i = 0; i < obj.length; i++) {
    var currentKeys = Object.keys(obj[i]);
    for (var j = 0; j < currentKeys.length; j++) {
        for (var k = 0; k < obj[i][currentKeys[j]].length; k++) {
            newObj.push({
                x: currentKeys[j],
                y: [obj[i][currentKeys[j]][k].StartDate, obj[i][currentKeys[j]][k].EndDate]
            });
        }
    }
}

为什么只限于第一个索引？如果它是一个数组，那么肯定有其他项不是“肯定”-我使用的是示例数据的代码片段-第三个嵌套循环可能不需要。如果没有超过1项，那么第三个循环不会增加时间复杂度，对吗？但如果有超过1项，您的解决方案将失败，这与时间复杂性无关。你有一个输入，你想要一个输出。输入可能在外部数组中有更多的条目，也可能没有-添加另一个嵌套的缩减器来创建一个混乱的3层嵌套会给代码增加不必要的复杂性，通常最好保持简单。然而，我已经更新了代码，使其具有额外的嵌套，但为了保持它看起来简单，我将其更改为
forEach
，而不是
reduce
。Luke Storry的解决方案更易于阅读，只需稍加修改即可使其适用于整个阵列。我发布的解决方案将数组作为oldArr使用，并将考虑数组的每一项。您应该尝试基于此代码实现一些东西。
[
  {
    "x": "20200714",
    "y": [
      "2020-07-14T11:05:31.151687000",
      "2020-07-14T12:11:59.673687000"
    ]
  },
  {
    "x": "20200714",
    "y": [
      "2020-07-14T13:05:31.151687000",
      "2020-07-14T14:11:59.673687000"
    ]
  },
  {
    "x": "20200715",
    "y": [
      "2020-07-15T14:05:31.151687000",
      "2020-07-15T15:11:59.673687000"
    ]
  }
]