跨性能较差的javascript对象数组映射Reduce

我试图在一些javascript对象上进行一些映射/缩减，但失败得很惨

来自后端的数据看起来是这样的：

[
  {table:"a1", data: {colA:1,colB:2,colC:3}},
  {table:"a2", data: {colA:2,colB:3,colC:4}},
  {table:"a3", data: {colA:3,colB:4,colC:5}}
]

Recharts需要以下格式的数据（将源数据键作为结果的唯一“名称”键）

我当前的解决方案是当前的

O（n^n）

，因为我正在构建一个结果对象，并且每次都在它上面循环。我使用的是ECMA6/Babel和Lodash。任何指导都将不胜感激！谢谢

编辑：这是我目前的解决方案

var dest = []
Lodash.forEach(source,(o) => {
  var table = o.table;
  Lodash.forEach(o.data, (p,q) => {
    // See if the element is in the array
    const index = Lodash.findIndex(dest,(a) => {return a.name === q});
    if ( index === -1) {
      var obj = {};
      obj[table] = Number(p);
      obj.name = q;
      dest.push(obj);
    } else {
      dest[index][table] = Number(p);
    }
  })
});

---

首先，算法的速度实际上是O（n^n^n），因为嵌套了3个循环。我简化它的方法是首先使用一个对象，然后从该对象创建一个数组。像这样：

函数转换（原始）{
var tmp={}；
for（var表格索引原件）{
var tableObj=原始[表格索引]；
for（表对象数据中的var colKey）{
var col=表对象数据[colKey]；
if（tmp[colKey]==未定义）{
tmp[colKey]={name:colKey}；
}
tmp[colKey][tableObj.table]=col
}
}
var输出=[]；
对于（tmp中的var指数）{
push（tmp[index]）；
}
返回输出；
}
原始变量=[
{表：“a1”，数据：{colA:1，colB:2，colC:3}，
{表：“a2”，数据：{colA:2，colB:3，colC:4}，
{表：“a3”，数据：{colA:3，colB:4，colC:5}
]
console.log（转换（原始））首先，算法的速度实际上是O（n^n^n），因为嵌套了3个循环。我简化它的方法是首先使用一个对象，然后从该对象创建一个数组。像这样：


函数转换（原始）{
var tmp={}；
for（var表格索引原件）{
var tableObj=原始[表格索引]；
for（表对象数据中的var colKey）{
var col=表对象数据[colKey]；
if（tmp[colKey]==未定义）{
tmp[colKey]={name:colKey}；
}
tmp[colKey][tableObj.table]=col
}
}
var输出=[]；
对于（tmp中的var指数）{
push（tmp[index]）；
}
返回输出；
}
原始变量=[
{表：“a1”，数据：{colA:1，colB:2，colC:3}，
{表：“a2”，数据：{colA:2，colB:3，colC:4}，
{表：“a3”，数据：{colA:3，colB:4，colC:5}
]
console.log（转换（原始））如果使用地图跟踪最终列，则可以大大简化此操作。通过边走边将它们存储在地图中，可以获得恒定查找时间的好处

如果我们说表的数量是
N
，列的数量是
M
，那么你会得到O（N*M）


让输入=[
{表：“a1”，数据：{colA:1，colB:2，colC:3}，
{表：“a2”，数据：{colA:2，colB:3，colC:4}，
{表：“a3”，数据：{colA:3，colB:4，colC:5}
];
设期望输出=[
{名称：'colA'，a1:1，a2:2，a3:3}，
{名称：'colB'，a1:2，a2:3，a3:4}，
{name:'colC'，a1:3，a2:4，a3:5}
];
让keys=null；
设map=null；
input.forEach（行=>{
if（map==null）{
//缓存列名
keys=Object.keys（row.data）；
//生成对象，例如`{name:'colA'}`
//并将其储存在“可乐”钥匙处
map=键
.减少（（o，k）=>（o[k]={
姓名：k
}，o），{}）；
}
//对于每一列（“可乐”、“可乐”等）
keys.forEach（key=>{
//为表名创建新属性
//（‘a1’、‘a2’等）
//并从输入中复制匹配的列值
map[key][row.table]=row.data[key]；
});
});
//将贴图转换为仅包含值的数组
让输出=对象值（映射）；
log（JSON.stringify（输出）==JSON.stringify（desiredOutput））；
控制台日志（输出）如果使用地图跟踪最终列，则可以大大简化此操作。通过边走边将它们存储在地图中，可以获得恒定查找时间的好处

如果我们说表的数量是
N
，列的数量是
M
，那么你会得到O（N*M）


让输入=[
{表：“a1”，数据：{colA:1，colB:2，colC:3}，
{表：“a2”，数据：{colA:2，colB:3，colC:4}，
{表：“a3”，数据：{colA:3，colB:4，colC:5}
];
设期望输出=[
{名称：'colA'，a1:1，a2:2，a3:3}，
{名称：'colB'，a1:2，a2:3，a3:4}，
{name:'colC'，a1:3，a2:4，a3:5}
];
让keys=null；
设map=null；
input.forEach（行=>{
if（map==null）{
//缓存列名
keys=Object.keys（row.data）；
//生成对象，例如`{name:'colA'}`
//并将其储存在“可乐”钥匙处
map=键
.减少（（o，k）=>（o[k]={
姓名：k
}，o），{}）；
}
//对于每一列（“可乐”、“可乐”等）
keys.forEach（key=>{
//为表名创建新属性
//（‘a1’、‘a2’等）
//并从输入中复制匹配的列值
map[key][row.table]=row.data[key]；
});
});
//将贴图转换为仅包含值的数组
让输出=对象值（映射）；
log（JSON.stringify（输出）==JSON.stringify（desiredOutput））；
控制台日志（输出）确切的问题是什么？如果您需要性能，请将原始
用于
。能否发布您当前的解决方案？请向我们展示您当前的代码。您的解决方案具有复杂性
O（n²m）
，而不是
O（n^n）
确切的问题是什么？如果您需要性能，请使用raw
for
。您可以发布您当前的解决方案吗？请向我们展示您当前的代码。您的解决方案具有复杂性
O（n²m）
，而不是
O（n^n）
很好地使用了一些辅助方法，例如reduce和forEach。请注意，它们也会产生自己的开销。我对我们的两个解决方案进行了速度测试，您的解决方案在1000000次迭代中以1500ms的速度计时，而我的解决方案在相同的迭代次数中以900ms的速度计时。我们之间唯一的区别就是
var dest = []
Lodash.forEach(source,(o) => {
  var table = o.table;
  Lodash.forEach(o.data, (p,q) => {
    // See if the element is in the array
    const index = Lodash.findIndex(dest,(a) => {return a.name === q});
    if ( index === -1) {
      var obj = {};
      obj[table] = Number(p);
      obj.name = q;
      dest.push(obj);
    } else {
      dest[index][table] = Number(p);
    }
  })
});