Javascript 如何获得所需的输出？

我正在使用一些API&我设法按以下顺序格式化数据：

数据采用这种格式

const data = [
  [
      {'type' :'a', 'rate': 5}
  ],
  [
      {'type' :'a', 'rate': 7},
      {'type' :'b', 'rate': 2},
      {'type' :'c', 'rate': 4},
  ],
  [
      {'type' :'b', 'rate': 1},
      {'type' :'c', 'rate': 4}
  ],
  [
      {'type' :'a', 'rate': 8},
      {'type' :'c', 'rate': 4}
  ]
]

从上述数据中，我希望按此顺序提取点特性。 输出要求如下：

[
  ['a', 5, 7, 0, 8],
  ['b', 0, 2, 1, 0],
  ['c', 0, 4, 3, 4]
]

当我开始工作时，我知道我需要帮助。由于我是这个领域的新手，我想寻求一些帮助

我尝试过：

data.forEach( (list) => {
  const group = list.reduce((acc, val) => {
    const dataType = val.type
    if(!acc[dataType]){
      acc[dataType] =[]
    }
    acc.push(dataType, val.rate)
    return acc
  }, [])
  console.log(group)
})

---

我无法比较数组中的两个列表。解决这个问题的最佳方法是什么？

您可以

减少阵列。将每个
类型添加为键，将输出中所需的数组添加为累加器中的值。如果该键尚不存在，请添加
[键入，…数组（i）.fill（0）]
作为默认值。如果已经存在，请更新
i+1
索引。在开始时向累加器中的每个数组添加默认值
0
，因为当前迭代中可能缺少一些键


const data=[{type:“a”，rate:5}]，{type:“a”，rate:7}，{type:“b”，rate:2}，{type:“c”，rate:4}，][{{type:“b”，rate:1}，{type:“c”，rate:4}]，{type:“a”，rate:8}，{type:“c”，rate:4}]；
常量组=数据减少（（acc、arr、i）=>{
用于（acc中的常量类型）
acc[类型]。推送（0）；
用于（arr的常数{type，rate}）{
acc[type]=acc[type]| |[type，…数组（i）.fill（0）]
acc[类型][i+1]=费率
}
返回acc
}, {})
console.log（Object.values（group））
const数据=[
[
{'type'：'a'，'rate'：5}
],
[
{'type'：'a'，'rate'：7}，
{'type'：'b'，'rate'：2}，
{'type'：'c'，'rate'：4}，
],
[
{'type'：'b'，'rate'：1}，
{'type'：'c'，'rate'：4}
],
[
{'type'：'a'，'rate'：8}，
{'type'：'c'，'rate'：4}
]
];
var类型=[]；
data.forEach（列表=>
list.forEach（元素=>{
如果（！types.includes（element.type））types.push（element.type）；
} )
);
console.log(
类型.减少（（累加器，类型）=>{
常量计数=[类型]；
data.forEach（列表=>{
const match=list.find（it=>it.type==type）；
push（（匹配|{rate:0}）.rate）；
} );
蓄能器。推动（计数）；
回流蓄能器；
}, [] )
);显然，我会这样做，因为我就是这样做的

按键存储信息，这是数据类型。
我们需要确保以某种方式保留最大大小，因此使用
max
变量。
一些map语句稍后用于重组为我们的目标


const数据=[
[
{'type'：'a'，'rate'：5}
],
[
{'type'：'a'，'rate'：7}，
{'type'：'b'，'rate'：2}，
{'type'：'c'，'rate'：4}，
],
[
{'type'：'b'，'rate'：1}，
{'type'：'c'，'rate'：4}
],
[
{'type'：'a'，'rate'：8}，
{'type'：'c'，'rate'：4}
]
]
常量映射={}
设max=0
data.forEach（（列表，i）=>{
list.forEach（（val）=>{
常量{type}=val
映射[类型]=映射[类型]| |[]
映射[type][i]=val.rate
})
max=i
})
const result=Object.keys（mapping.map）（key=>{
映射[key][max]=映射[key][max]|0
返回[key，…映射[key]].map（val=>val | | 0）
})
document.getElementById（'result'）.innerHTML=JSON.stringify（result）
我做了很长一段路


var数据=[
[{“类型”：“a”，“比率”：5}]，
[{“类型”：“a”，“速率”：7}，{“类型”：“b”，“速率”：2}，{“类型”：“c”，“速率”：4}]，
[{“类型”：“b”，“速率”：1}，{“类型”：“c”，“速率”：4}]，
[{“类型”：“a”，“速率”：8}，{“类型”：“c”，“速率”：4}]
];
var result={}，index=0；
data.forEach（列表=>{
list.forEach（项=>{
如果（！结果[项目类型]）
结果[项目类型]=
{index:index++，type:item.type，rates:Array（data.length）.fill（0）}；
}
);
}
);
对于（var i=0；i{
结果[item.type]。比率[i]=item.rate；
}
);
};
var-resArr=[]；
Object.entries（result.forEach）（r=>{
resArr[r[1]。索引]=[r[0]]。concat（r[1]。速率）；
}
);
log（JSON.stringify（resArr））每个
列表
不重复字母字符。重复的字母字符位于
数据
数组的其他元素中。我建议首先展平您的
数据
数组。如果我展平我的数据，我能得到0吗？如果列表不包含该类型，那么输出应该是0.Mmm，这是一个很好的观点。